mmc/lingma-proxy-compose
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: mmc:a3a9c278f67b6e50005b9a317613b2bfc64e5cea
Branches Tags
mmc:main
...
compare: mmc:main
Branches Tags
mmc:main

13 Commits
a3a9c278f6 ... main

Author SHA1 Message Date
GitHub Actions
450faefaf9 Add API key authentication for proxy endpoints. 
Support multiple API keys from config, env, and CLI, enforce auth on non-public endpoints, and pass keys through remote deploy verification.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
 2026-05-08 13:08:27 +08:00
GitHub Actions
c1a0fe2949 Switch remote deploy to vendored source builds 
Move remote deployment to a vendored source bundle built on the target host via Docker so redeploys no longer require local cross-compilation or host Go installation.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
 2026-05-08 12:19:18 +08:00
GitHub Actions
bb27566e38 Add reusable remote deploy script 
Automate the Linux binary upload, remote container rebuild, and health checks so the proxy can be redeployed to the server with a single command.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
 2026-05-08 07:53:27 +08:00
GitHub Actions
a4cedecca6 Add Docker Compose Lingma bootstrap support 
Package the proxy for Docker Compose deployments and add Lingma bootstrap, session restore, and runtime status support for containerized remote usage.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
 2026-05-07 23:56:05 +08:00
lutc5
86fbdbc40c Release v1.4.9 remote image routing 2026-05-07 16:44:59 +08:00
lutc5
68e7843a45 Release v1.4.8 remote detection fixes 2026-05-06 17:52:42 +08:00
lutc5
a87b2eefe4 Fix Windows remote URL detection 2026-05-06 16:58:27 +08:00
lutc5
22f793c188 Release v1.4.7 with unlimited default timeout 2026-05-06 16:29:35 +08:00
lutc5
fe1d5b5348 Fix tool loop handling and count tokens endpoint 2026-05-06 15:58:37 +08:00
lutc5
1c349227a3 Rename product to Lingma Proxy 2026-05-06 15:03:04 +08:00
lutc5
7eb68f8bdc Release v1.4.6 2026-05-06 12:43:55 +08:00
lutc5
4622dee883 Release v1.4.5 2026-05-06 12:08:39 +08:00
lutc5
d2a0441072 docs: update desktop screenshots 2026-05-06 11:28:33 +08:00
1358 changed files with 500231 additions and 378 deletions
Expand all files Collapse all files

23
.env.example Normal file
View File

@@ -0,0 +1,23 @@
LINGMA_PROXY_PORT=8095
LINGMA_REMOTE_BASE_URL=https://lingma.alibabacloud.com
LINGMA_REMOTE_AUTH_FILE=/secrets/credentials.json
LINGMA_BOOTSTRAP_ENABLED=true
LINGMA_SOURCE_TYPE=marketplace
LINGMA_VSIX_URL=
LINGMA_MARKETPLACE_PUBLISHER=Alibaba-Cloud
LINGMA_MARKETPLACE_EXTENSION=tongyi-lingma
LINGMA_BIN=/app/data/bin/Lingma
LINGMA_BOOTSTRAP_OUTPUT_DIR=/app/data/bin/release
LINGMA_BOOTSTRAP_ALWAYS=true
LINGMA_FORCE_REFRESH=false
LINGMA_WORK_DIR=/app/data/.lingma/vscode/sharedClientCache
LINGMA_SESSION_BUNDLE=
LINGMA_SESSION_BUNDLE_FILE=/secrets/session.bundle
LINGMA_PROXY_BACKEND=remote
LINGMA_PROXY_SESSION_MODE=auto
LINGMA_PROXY_MODEL=kmodel
LINGMA_PROXY_TIMEOUT_SECONDS=0
LINGMA_REMOTE_FALLBACK_ENABLED=true

30
.github/workflows/release.yml vendored
View File

@@ -60,14 +60,14 @@ jobs:
- name: Build CLI
run: |
mkdir -p dist
CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -trimpath -ldflags "-s -w" -o dist/lingma-ipc-proxy ./cmd/lingma-ipc-proxy
tar -C dist -czf "lingma-ipc-proxy_${RELEASE_TAG}_darwin_arm64.tar.gz" lingma-ipc-proxy
CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -trimpath -ldflags "-s -w" -o dist/lingma-proxy ./cmd/lingma-ipc-proxy
tar -C dist -czf "lingma-proxy_${RELEASE_TAG}_darwin_arm64.tar.gz" lingma-proxy
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
name: cli-macos
path: lingma-ipc-proxy_${{ env.RELEASE_TAG }}_darwin_arm64.tar.gz
path: lingma-proxy_${{ env.RELEASE_TAG }}_darwin_arm64.tar.gz
build-cli-windows:
name: Build CLI Windows
@@ -86,14 +86,14 @@ jobs:
shell: pwsh
run: |
.\scripts\build.ps1 -Clean
$asset = "lingma-ipc-proxy_${env:RELEASE_TAG}_windows_amd64.zip"
Compress-Archive -Path .\dist\lingma-ipc-proxy.exe -DestinationPath $asset -Force
$asset = "lingma-proxy_${env:RELEASE_TAG}_windows_amd64.zip"
Compress-Archive -Path .\dist\lingma-proxy.exe -DestinationPath $asset -Force
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
name: cli-windows
path: lingma-ipc-proxy_${{ env.RELEASE_TAG }}_windows_amd64.zip
path: lingma-proxy_${{ env.RELEASE_TAG }}_windows_amd64.zip
build-desktop-macos:
name: Build Desktop macOS
@@ -130,17 +130,17 @@ jobs:
run: |
APP_PATH="$(find desktop/build/bin -maxdepth 1 -name '*.app' -print -quit)"
test -n "$APP_PATH"
test "$(basename "$APP_PATH")" = "Lingma IPC Proxy.app"
ditto -c -k --sequesterRsrc --keepParent "$APP_PATH" "lingma-ipc-proxy-desktop_${RELEASE_TAG}_darwin_arm64.zip"
test "$(basename "$APP_PATH")" = "Lingma Proxy.app"
ditto -c -k --sequesterRsrc --keepParent "$APP_PATH" "lingma-proxy-desktop_${RELEASE_TAG}_darwin_arm64.zip"
DMG_ROOT="$(mktemp -d)"
cp -R "$APP_PATH" "$DMG_ROOT/"
ln -s /Applications "$DMG_ROOT/Applications"
hdiutil create \
-volname "Lingma IPC Proxy" \
-volname "Lingma Proxy" \
-srcfolder "$DMG_ROOT" \
-ov \
-format UDZO \
"lingma-ipc-proxy-desktop_${RELEASE_TAG}_darwin_arm64.dmg"
"lingma-proxy-desktop_${RELEASE_TAG}_darwin_arm64.dmg"
rm -rf "$DMG_ROOT"
- name: Upload artifact
@@ -148,8 +148,8 @@ jobs:
with:
name: desktop-macos
path: |
lingma-ipc-proxy-desktop_${{ env.RELEASE_TAG }}_darwin_arm64.zip
lingma-ipc-proxy-desktop_${{ env.RELEASE_TAG }}_darwin_arm64.dmg
lingma-proxy-desktop_${{ env.RELEASE_TAG }}_darwin_arm64.zip
lingma-proxy-desktop_${{ env.RELEASE_TAG }}_darwin_arm64.dmg
build-desktop-windows:
name: Build Desktop Windows
@@ -191,14 +191,14 @@ jobs:
$exe = Get-ChildItem .\desktop\build\bin -Filter *.exe | Select-Object -First 1
if (-not $exe) { throw "Desktop exe was not produced" }
if ($exe.Name -ne "LingmaProxy.exe") { throw "Unexpected desktop exe name: $($exe.Name)" }
$asset = "lingma-ipc-proxy-desktop_${env:RELEASE_TAG}_windows_amd64.zip"
$asset = "lingma-proxy-desktop_${env:RELEASE_TAG}_windows_amd64.zip"
Compress-Archive -Path $exe.FullName -DestinationPath $asset -Force
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
name: desktop-windows
path: lingma-ipc-proxy-desktop_${{ env.RELEASE_TAG }}_windows_amd64.zip
path: lingma-proxy-desktop_${{ env.RELEASE_TAG }}_windows_amd64.zip
publish:
name: Publish Release
@@ -218,7 +218,7 @@ jobs:
- name: Generate checksums
run: |
cd artifacts
sha256sum * > "lingma-ipc-proxy_${RELEASE_TAG}_sha256.txt"
sha256sum * > "lingma-proxy_${RELEASE_TAG}_sha256.txt"
- name: Create or update release
uses: softprops/action-gh-release@v2

39
CHANGELOG.md
View File

@@ -2,7 +2,44 @@
## Unreleased
- Nothing yet.
## v1.4.9 - 2026-05-07
- Added Remote-mode image routing: image requests now use the proven Lingma IPC image pipeline instead of sending local/data URLs directly to the remote chat endpoint.
- Added mixed image + tool handling: the proxy extracts image context through IPC, then returns to Remote API native tool calling so clients still receive proper `tool_calls` / `tool_use`.
- Fixed multi-turn image follow-ups by reusing the most recent user image from request history when the latest user turn says things like "continue based on the previous image".
- Improved Remote API tool compatibility by forwarding structured messages, tool definitions, tool choice, and native remote tool-call deltas instead of prompt-emulating tools in Remote mode.
- Added regression tests for remote structured tools, image routing, image-context injection, and previous-turn image reuse.
- Verified the production desktop app launch path from `/Applications/Lingma Proxy.app`, including pure image, multi-turn image, and image + forced tool-call requests.
## v1.4.8 - 2026-05-06
- Fixed Remote API base URL auto-detection so Lingma OSS/static asset hosts are rejected and cannot be used as API endpoints.
- Improved Remote API model-list 404 errors with a clear hint to manually set the official or enterprise remote API domain.
- Restored desktop input editing shortcuts by using the native Wails edit menu, fixing copy, paste, cut, undo, redo, and select-all in app input fields.
- Added regression tests for Windows/Lingma log URL parsing, missing leading `h` repair, and OSS-host rejection.
## v1.4.7 - 2026-05-06
- Renamed user-facing product, desktop app, release assets, and documentation from Lingma IPC Proxy to Lingma Proxy.
- Clarified that Remote API mode is the recommended default and that only IPC plugin mode is based on the `coolxll/lingma-ipc-proxy` protocol discovery.
- Added `lingma-proxy.json` and `~/.config/lingma-proxy/config.json` config lookup/write paths while keeping legacy `lingma-ipc-proxy` config fallback.
- Added a desktop top-bar force quit button that stops the proxy and exits the app on macOS and Windows.
- Added Anthropic `/v1/messages/count_tokens` compatibility for Claude Code v2.1.129+.
- Reduced prompt-emulated tool loops by allowing final answers after tool results and dropping tool calls with missing required arguments.
- Prevented hosted Anthropic `web_search` from being short-circuited again after a `tool_result` follow-up.
- Changed the default proxy request timeout to `0`, meaning no proxy-level per-request deadline. Positive timeout values still enable timeout-triggered remote fallback.
## v1.4.6 - 2026-05-06
- Added the VS Code Lingma plugin shared cache directory `~/.lingma/vscode/sharedClientCache` to remote credential auto-detection.
- This fixes Windows setups where Lingma is installed through the VS Code extension and stores `cache/user` plus `cache/id` under the plugin shared client cache.
## v1.4.5 - 2026-05-06
- Improved Windows remote credential detection for Lingma App installations.
- Remote API mode now checks `cache/user` before machine-id lookup so missing-login errors are more accurate.
- Expanded machine-id discovery to recursive Lingma app logs and VS Code Lingma plugin logs instead of only `logs/lingma.log`.
- Added support for additional machine-id log formats such as `machine_id`, `machineId`, and JSON-style fields.
## v1.4.4 - 2026-05-05

14
Dockerfile Normal file
View File

@@ -0,0 +1,14 @@
FROM golang:1.23.6 AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /out/lingma-proxy ./cmd/lingma-ipc-proxy
FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates wget && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY --from=build /out/lingma-proxy /usr/local/bin/lingma-proxy
EXPOSE 8095
CMD ["lingma-proxy", "--host", "0.0.0.0", "--port", "8095", "--backend", "remote"]

125
README.md
View File

@@ -2,18 +2,18 @@
[English](./README.md) | [简体中文](./README.zh-CN.md)
Lingma Proxy exposes Tongyi Lingma as standard **OpenAI-compatible** and **Anthropic-compatible** HTTP APIs. It can use either the local IDE plugin IPC channel or an experimental remote API backend, and ships as both a CLI proxy service and a cross-platform desktop app for macOS and Windows.
Lingma Proxy exposes Tongyi Lingma as standard **OpenAI-compatible** and **Anthropic-compatible** HTTP APIs. It can use either the recommended Remote API backend or the local IDE plugin IPC channel, and ships as both a CLI proxy service and a cross-platform desktop app for macOS and Windows.
The project is designed for tools such as Claude Code, Cline, Continue, OpenCode, custom agents, and any client that can talk to OpenAI or Anthropic style APIs.
The proxy now supports two backend modes:
- **Remote API mode (default, experimental)**: imports the local Lingma login cache or an explicit credential file and calls Lingma remote APIs directly. This feels more like an official API, does not depend on an IDE IPC session, and is currently the recommended mode for Claude Code / Hermes style agents.
- **IPC plugin mode**: connects to the local Lingma IDE plugin over WebSocket / Named Pipe. This keeps behavior closest to the IDE plugin and is useful as a compatibility fallback.
- **Remote API mode (default, recommended)**: imports the local Lingma login cache or an explicit credential file and calls Lingma remote APIs directly. This behaves closest to a normal hosted API, avoids IDE/plugin session and environment limits, and is currently the best mode for Claude Code / Hermes style agents.
- **IPC plugin mode**: connects to the local Lingma IDE plugin over WebSocket / Named Pipe. This keeps behavior closest to the IDE plugin, but it can inherit IDE session lifetime, local plugin state, and environment constraints, so it is mainly a compatibility fallback.
## Current Version
The current desktop line is `v1.4.4`.
The current desktop line is `v1.4.9`.
See [CHANGELOG.md](./CHANGELOG.md) for release history.
@@ -21,22 +21,22 @@ Release builds are produced by GitHub Actions for:
| Asset | Platform | Purpose |
| --- | --- | --- |
| `lingma-ipc-proxy_<tag>_darwin_arm64.tar.gz` | macOS | CLI proxy |
| `lingma-ipc-proxy_<tag>_windows_amd64.zip` | Windows | CLI proxy |
| `lingma-ipc-proxy-desktop_<tag>_darwin_arm64.dmg` | macOS Apple Silicon | Drag-to-install desktop app |
| `lingma-ipc-proxy-desktop_<tag>_darwin_arm64.zip` | macOS Apple Silicon | Raw `.app` archive |
| `lingma-ipc-proxy-desktop_<tag>_windows_amd64.zip` | Windows | Desktop app |
| `lingma-ipc-proxy_<tag>_sha256.txt` | all | Checksums |
| `lingma-proxy_<tag>_darwin_arm64.tar.gz` | macOS | CLI proxy |
| `lingma-proxy_<tag>_windows_amd64.zip` | Windows | CLI proxy |
| `lingma-proxy-desktop_<tag>_darwin_arm64.dmg` | macOS Apple Silicon | Drag-to-install desktop app |
| `lingma-proxy-desktop_<tag>_darwin_arm64.zip` | macOS Apple Silicon | Raw `.app` archive |
| `lingma-proxy-desktop_<tag>_windows_amd64.zip` | Windows | Desktop app |
| `lingma-proxy_<tag>_sha256.txt` | all | Checksums |
### Which Package Should I Download?
| Your system | Recommended asset | Notes |
| --- | --- | --- |
| macOS on Apple Silicon (M1/M2/M3/M4) | `lingma-ipc-proxy-desktop_<tag>_darwin_arm64.dmg` | Open the DMG and drag `Lingma IPC Proxy.app` to `Applications`. |
| macOS on Apple Silicon, portable archive | `lingma-ipc-proxy-desktop_<tag>_darwin_arm64.zip` | Same app, but packaged as a zip instead of a drag-to-install DMG. |
| Windows x64 / x86_64 / AMD64 | `lingma-ipc-proxy-desktop_<tag>_windows_amd64.zip` | This is the correct package for normal 64-bit Windows PCs, including Intel and AMD CPUs. |
| macOS CLI only | `lingma-ipc-proxy_<tag>_darwin_arm64.tar.gz` | Terminal-only proxy binary. |
| Windows CLI only | `lingma-ipc-proxy_<tag>_windows_amd64.zip` | Terminal-only proxy binary for 64-bit Windows. |
| macOS on Apple Silicon (M1/M2/M3/M4) | `lingma-proxy-desktop_<tag>_darwin_arm64.dmg` | Open the DMG and drag `Lingma Proxy.app` to `Applications`. |
| macOS on Apple Silicon, portable archive | `lingma-proxy-desktop_<tag>_darwin_arm64.zip` | Same app, but packaged as a zip instead of a drag-to-install DMG. |
| Windows x64 / x86_64 / AMD64 | `lingma-proxy-desktop_<tag>_windows_amd64.zip` | This is the correct package for normal 64-bit Windows PCs, including Intel and AMD CPUs. |
| macOS CLI only | `lingma-proxy_<tag>_darwin_arm64.tar.gz` | Terminal-only proxy binary. |
| Windows CLI only | `lingma-proxy_<tag>_windows_amd64.zip` | Terminal-only proxy binary for 64-bit Windows. |
There is currently no separate `windows_arm64` package. On a normal x64 Windows machine, choose `windows_amd64`.
@@ -90,6 +90,7 @@ Compared with the original protocol proof of concept, this repository focuses on
- **Anthropic streaming tool-call hardening** so streaming clients such as Claude Code receive final `tool_use` events instead of premature refusal text when tools are present.
- **Image input** for OpenAI `image_url` and Anthropic image blocks.
- **Local and remote image normalization** for data URLs, HTTP URLs, `file://` URLs, and absolute local paths, with automatic JPEG downscaling for large images.
- **Remote-mode image fallback** so image requests use the proven Lingma IPC image pipeline; image + tool requests extract image context through IPC and then return to Remote API native tool calling.
- **Request log image redaction** so large base64 payloads are visible as image markers instead of breaking the desktop log view.
- **More request parameter compatibility** so stricter clients can connect without custom patches.
- **Full request and response recording** in the desktop app for debugging 400/500 errors.
@@ -130,9 +131,12 @@ flowchart LR
Service --> Session["Session Manager"]
Service --> Tools["Tool Emulation"]
Service --> Models["Model Discovery"]
Service --> Images["Image Router"]
Service --> Backend{"Backend Mode"}
Backend --> Transport["IPC Plugin Transport"]
Backend --> Remote["Remote API Client"]
Images -->|"image requests"| Transport
Images -->|"image + tools: extract context"| Remote
Transport --> Pipe["Windows Named Pipe"]
Transport --> WS["macOS / Windows WebSocket"]
Pipe --> Lingma["Tongyi Lingma IDE Plugin"]
@@ -165,18 +169,18 @@ flowchart LR
If auto detection fails, set the path manually in the desktop Settings page or pass CLI flags:
```bash
lingma-ipc-proxy --transport websocket --ws-url ws://127.0.0.1:36510 --port 8095
lingma-ipc-proxy --transport pipe --pipe '\\.\pipe\lingma-ipc'
lingma-proxy --transport websocket --ws-url ws://127.0.0.1:36510 --port 8095
lingma-proxy --transport pipe --pipe '\\.\pipe\lingma-ipc'
```
## Backend Modes
### Remote API Mode (Default, Experimental)
### Remote API Mode (Default, Recommended)
Remote mode calls Lingma's remote API directly:
```bash
lingma-ipc-proxy --backend remote --port 8095
lingma-proxy --backend remote --port 8095
```
By default it reads the local Lingma login cache in read-only mode:
@@ -193,10 +197,10 @@ XDG config/state Lingma cache paths when present
You can also pass an explicit credential file:
```bash
lingma-ipc-proxy \
lingma-proxy \
--backend remote \
--remote-base-url https://lingma.alibabacloud.com \
--remote-auth-file ~/.config/lingma-ipc-proxy/credentials.json
--remote-auth-file ~/.config/lingma-proxy/credentials.json
```
Credential file format:
@@ -216,10 +220,12 @@ Credential file format:
Notes:
- Remote API mode is the recommended default for day-to-day agent usage. It bypasses the IDE/plugin IPC runtime, so it is less affected by plugin session state, IDE working directory, or local extension environment limitations.
- Remote mode does not write or migrate login state. It only reads the local Lingma cache or the credential file you provide.
- If your Lingma plugin uses a dedicated domain, remote mode first uses `--remote-base-url`, `LINGMA_REMOTE_BASE_URL`, or the JSON config field. If those are empty, it scans Lingma's local logs on macOS, Windows, and Linux for endpoint hints such as `endpoint config:` and marketplace service URLs.
- The desktop Settings page shows the resolved remote domain and detection source without exposing tokens.
- `/v1/models` in remote mode returns remote API model keys, which may not match the IPC plugin display IDs such as `MiniMax-M2.7` or `Kimi-K2.6`.
- Image requests in remote mode are routed through the IPC image pipeline because the direct remote chat endpoint ignores local `file://` and data URL image payloads. If a request also contains tools, Lingma Proxy first extracts image context through IPC and then sends the tool-capable turn through Remote API native tool calling.
- Local validation passed `/health`, `/v1/models`, OpenAI streaming/non-streaming chat, and Claude Code Anthropic + Bash tool use. Claude Code full tool runs are much slower than simple OpenAI requests because the client sends a large context and performs a second tool-result turn.
- This mode is inspired by the remote API and credential-signing research in [ZipperCode/lingma2api](https://github.com/ZipperCode/lingma2api), integrated here as a switchable backend under the existing OpenAI / Anthropic / desktop app architecture.
@@ -228,10 +234,10 @@ Notes:
IPC mode talks to the local Lingma IDE plugin:
```bash
lingma-ipc-proxy --backend ipc --transport auto --port 8095
lingma-proxy --backend ipc --transport auto --port 8095
```
Use this when VS Code / the Lingma plugin is already running, when you want plugin session behavior, or when you want the model list exposed by the local plugin.
Use this when VS Code / the Lingma plugin is already running, when you want plugin session behavior, or when you want the exact model list exposed by the local plugin. Compared with Remote API mode, IPC mode is more coupled to the IDE/plugin process and can be affected by that process's session, current project, and local environment.
## Quick Start
@@ -239,27 +245,73 @@ Use this when VS Code / the Lingma plugin is already running, when you want plug
1. Install VS Code and the Tongyi Lingma extension.
2. Log in to Tongyi Lingma and verify the Lingma panel can chat normally.
3. Download the desktop asset from [Releases](https://github.com/Lutiancheng1/lingma-ipc-proxy/releases).
4. Start `Lingma IPC Proxy`.
3. Download the desktop asset from [Releases](https://github.com/Lutiancheng1/lingma-proxy/releases).
4. Start `Lingma Proxy`.
5. Click `探测模型` after the proxy is running.
6. Configure clients to use `http://127.0.0.1:8095`.
### CLI
Run directly from source:
```bash
git clone https://github.com/Lutiancheng1/lingma-ipc-proxy.git
cd lingma-ipc-proxy
go build -o ./dist/lingma-ipc-proxy ./cmd/lingma-ipc-proxy
./dist/lingma-ipc-proxy --host 127.0.0.1 --port 8095 --session-mode auto
git clone https://github.com/Lutiancheng1/lingma-proxy.git
cd lingma-proxy
go run ./cmd/lingma-ipc-proxy --host 127.0.0.1 --port 8095 --session-mode auto
```
Build an explicit binary only when you want one:
```bash
go build -o ./dist/lingma-proxy ./cmd/lingma-ipc-proxy
./dist/lingma-proxy --host 127.0.0.1 --port 8095 --session-mode auto
```
Windows:
```powershell
.\scripts\build.ps1
.\dist\lingma-ipc-proxy.exe --host 127.0.0.1 --port 8095 --session-mode auto
.\dist\lingma-proxy.exe --host 127.0.0.1 --port 8095 --session-mode auto
```
### Server Deployment Without CI
For Linux servers where you do not want to cross-compile locally, check in `vendor/` and let the target host build from source:
```bash
go mod vendor
REMOTE_HOST=150.158.105.6 \
REMOTE_USER=root \
REMOTE_PASSWORD='your-password' \
./scripts/deploy-remote.sh
```
The script uploads `cmd/`, `internal/`, `vendor/`, `go.mod`, and `go.sum`, prepares a Docker build context on the server, then rebuilds the runtime image there with a multi-stage Docker build. The remote host needs `docker`, `tar`, and `curl`; it does not need a host Go installation, but it does need network access to pull the base Docker images if they are not already cached.
### API Authentication
Set one or more API keys with `LINGMA_PROXY_API_KEYS` or the JSON config field `api_keys`:
```bash
export LINGMA_PROXY_API_KEYS="key-one,key-two"
go run ./cmd/lingma-ipc-proxy --host 127.0.0.1 --port 8095
```
```json
{
"api_keys": ["key-one", "key-two"]
}
```
The deployment script also passes through `LINGMA_PROXY_API_KEYS`, so the same key set can be enabled on the remote server during deploy.
When keys are configured, all API endpoints except `/`, `/health`, `/runtime/status`, and `/v1/runtime/status` require authentication. Clients can send either:
- `Authorization: Bearer <key>`
- `x-api-key: <key>`
This works well with OpenAI-compatible clients that already expose an API key field.
## Client Configuration
### Claude Code
@@ -326,7 +378,7 @@ The proxy only reports models actually exposed by your Lingma plugin. The table
Default model when the client omits `model`: `kmodel` (`Kimi-K2.6` in the remote model list).
Remote mode enables timeout fallback by default. On timeout, upstream 5xx/429, or network interruption, the proxy only switches models if no streaming bytes have been sent to the client yet. Fallback candidates are filtered against the actual `/v1/models` response, so unavailable models are skipped. Default order:
Remote mode enables fallback by default. The default proxy request timeout is `0`, which means Lingma Proxy does not set its own per-request deadline and is suitable for long agent workflows. If you set `"timeout"` to a positive number of seconds, timeout errors can also trigger fallback. Upstream 5xx/429 or network interruption can trigger fallback regardless of the timeout setting, but the proxy only switches models if no streaming bytes have been sent to the client yet. Fallback candidates are filtered against the actual `/v1/models` response, so unavailable models are skipped. Default order:
`Kimi-K2.6 -> MiniMax-M2.7 -> Qwen3-Coder -> Qwen3.6-Plus -> Qwen3-Max -> Qwen3-Thinking`
@@ -335,7 +387,8 @@ Remote mode enables timeout fallback by default. On timeout, upstream 5xx/429, o
Default config file:
```text
./lingma-ipc-proxy.json
./lingma-proxy.json
./lingma-ipc-proxy.json # legacy fallback
```
Example:
@@ -352,7 +405,7 @@ Example:
"mode": "agent",
"shell_type": "zsh",
"session_mode": "auto",
"timeout": 300,
"timeout": 0,
"remote_fallback_enabled": true,
"remote_fallback_models": [
"kmodel",
@@ -387,7 +440,7 @@ Older builds rejected concurrent chat requests with a `rate_limit_error` saying
Example:
```bash
LINGMA_PROXY_MAX_CONCURRENT=8 lingma-ipc-proxy --port 8095
LINGMA_PROXY_MAX_CONCURRENT=8 lingma-proxy --port 8095
```
## Function Calling / Tool Calling
@@ -460,7 +513,7 @@ cd desktop
wails build -platform windows/amd64 -clean
```
The desktop bundle name is always `Lingma IPC Proxy`.
The desktop bundle name is always `Lingma Proxy`.
## Release Plan
@@ -480,4 +533,4 @@ Planned improvements:
## Acknowledgements
This project is based on the protocol insight and initial discovery work from [coolxll/lingma-ipc-proxy](https://github.com/coolxll/lingma-ipc-proxy). The core idea of connecting to Lingma's private local IPC protocol and exposing standard API endpoints came from that project. This fork extends the implementation with broader OpenAI/Anthropic compatibility, tool emulation, image handling, desktop app support, request/log inspection, cross-platform packaging, and release automation.
The **IPC plugin mode** is based on the protocol insight and initial discovery work from [coolxll/lingma-ipc-proxy](https://github.com/coolxll/lingma-ipc-proxy). That project first demonstrated that Lingma's private local IPC protocol can be bridged to standard HTTP API endpoints. Lingma Proxy keeps that IPC path as a compatibility backend and extends it with broader OpenAI/Anthropic compatibility, tool emulation, image handling, desktop app support, request/log inspection, cross-platform packaging, and release automation. The default **Remote API mode** is a separate backend that calls Lingma remote APIs directly and is documented independently above.

133
README.zh-CN.md
View File

@@ -2,7 +2,7 @@
[English](./README.md) | [简体中文](./README.zh-CN.md)
**Lingma Proxy** 是一个通义灵码 API 适配层。它既可以把 Lingma 插件的本地私有 IPC / WebSocket 能力转换成标准 **OpenAI 兼容接口** 和 **Anthropic 兼容接口**，也可以使用实验性的远端 API 模式直接调用 Lingma 远端接口，让 Claude Code、Cline、Continue、OpenCode、自研 Agent 等第三方客户端可以直接调用 Lingma 后端模型。
**Lingma Proxy** 是一个通义灵码 API 适配层。它可以通过默认推荐的远端 API 模式直接调用 Lingma 远端接口，也可以把 Lingma 插件的本地私有 IPC / WebSocket 能力转换成标准 **OpenAI 兼容接口** 和 **Anthropic 兼容接口**，让 Claude Code、Cline、Continue、OpenCode、自研 Agent 等第三方客户端可以直接调用 Lingma 后端模型。
项目同时提供两种使用方式：
@@ -11,12 +11,12 @@
代理后端支持两种模式：
- **远端 API 模式（默认，实验）**：读取 Lingma 本地登录缓存或显式凭据，直接调用 Lingma 远端接口。优点是不依赖 IDE 插件窗口和 IPC 会话，体验更像官方 API；目前更推荐给 Claude Code / Hermes 这类本地 Agent。
- **IPC 插件模式**：连接本机 Lingma IDE 插件的 WebSocket / Named Pipe。优点是更接近 IDE 插件上下文，适合作为兼容性兜底。
- **远端 API 模式（默认，推荐）**：读取 Lingma 本地登录缓存或显式凭据，直接调用 Lingma 远端接口。它更接近普通托管 API，不依赖 IDE 插件窗口、IPC 会话和插件执行环境；目前更推荐给 Claude Code / Hermes 这类本地 Agent。
- **IPC 插件模式**：连接本机 Lingma IDE 插件的 WebSocket / Named Pipe。它更接近 IDE 插件上下文，但会继承 IDE 会话生命周期、插件本地状态和环境限制，主要作为兼容性兜底。
## 当前版本
当前桌面端版本线：`v1.4.4`
当前桌面端版本线：`v1.4.9`
版本更新记录见 [CHANGELOG.md](./CHANGELOG.md)。
@@ -24,22 +24,22 @@ GitHub Actions 会在 Release 中产出：
| 产物 | 平台 | 用途 |
| --- | --- | --- |
| `lingma-ipc-proxy_<tag>_darwin_arm64.tar.gz` | macOS | CLI 代理 |
| `lingma-ipc-proxy_<tag>_windows_amd64.zip` | Windows | CLI 代理 |
| `lingma-ipc-proxy-desktop_<tag>_darwin_arm64.dmg` | Apple Silicon Mac | 拖拽安装桌面 App |
| `lingma-ipc-proxy-desktop_<tag>_darwin_arm64.zip` | Apple Silicon Mac | `.app` 压缩包 |
| `lingma-ipc-proxy-desktop_<tag>_windows_amd64.zip` | Windows | 桌面 App |
| `lingma-ipc-proxy_<tag>_sha256.txt` | 全平台 | 校验文件 |
| `lingma-proxy_<tag>_darwin_arm64.tar.gz` | macOS | CLI 代理 |
| `lingma-proxy_<tag>_windows_amd64.zip` | Windows | CLI 代理 |
| `lingma-proxy-desktop_<tag>_darwin_arm64.dmg` | Apple Silicon Mac | 拖拽安装桌面 App |
| `lingma-proxy-desktop_<tag>_darwin_arm64.zip` | Apple Silicon Mac | `.app` 压缩包 |
| `lingma-proxy-desktop_<tag>_windows_amd64.zip` | Windows | 桌面 App |
| `lingma-proxy_<tag>_sha256.txt` | 全平台 | 校验文件 |
### 应该下载哪个包？
| 你的系统 | 推荐下载 | 说明 |
| --- | --- | --- |
| Apple Silicon Mac（M1/M2/M3/M4） | `lingma-ipc-proxy-desktop_<tag>_darwin_arm64.dmg` | 打开 DMG 后把 `Lingma IPC Proxy.app` 拖到 `Applications`。 |
| Apple Silicon Mac，想要压缩包 | `lingma-ipc-proxy-desktop_<tag>_darwin_arm64.zip` | 和 DMG 是同一个 App，只是 zip 形式。 |
| Windows x64 / x86_64 / AMD64 | `lingma-ipc-proxy-desktop_<tag>_windows_amd64.zip` | 普通 64 位 Windows 电脑都选这个，包括 Intel 和 AMD CPU。 |
| 只想在 macOS 终端跑 CLI | `lingma-ipc-proxy_<tag>_darwin_arm64.tar.gz` | 只有命令行代理，没有桌面界面。 |
| 只想在 Windows 终端跑 CLI | `lingma-ipc-proxy_<tag>_windows_amd64.zip` | 只有命令行代理，没有桌面界面。 |
| Apple Silicon Mac（M1/M2/M3/M4） | `lingma-proxy-desktop_<tag>_darwin_arm64.dmg` | 打开 DMG 后把 `Lingma Proxy.app` 拖到 `Applications`。 |
| Apple Silicon Mac，想要压缩包 | `lingma-proxy-desktop_<tag>_darwin_arm64.zip` | 和 DMG 是同一个 App，只是 zip 形式。 |
| Windows x64 / x86_64 / AMD64 | `lingma-proxy-desktop_<tag>_windows_amd64.zip` | 普通 64 位 Windows 电脑都选这个，包括 Intel 和 AMD CPU。 |
| 只想在 macOS 终端跑 CLI | `lingma-proxy_<tag>_darwin_arm64.tar.gz` | 只有命令行代理，没有桌面界面。 |
| 只想在 Windows 终端跑 CLI | `lingma-proxy_<tag>_windows_amd64.zip` | 只有命令行代理，没有桌面界面。 |
目前没有单独的 `windows_arm64` 包。常见 x64 Windows 机器请选择 `windows_amd64`。
@@ -53,6 +53,7 @@ GitHub Actions 会在 Release 中产出：
| Function Calling / Tools | 支持，使用工具调用模拟实现 |
| 多轮 Agent 工具循环 | 支持 |
| 图片输入 | 支持 base64、data URL、HTTP URL |
| 远端模式图片兜底 | 有图请求使用 IPC 图片链路；图片 + 工具请求先提取图片上下文，再回到 Remote API 原生工具调用 |
| 请求 / 响应完整日志 | 桌面端支持完整查看和复制 |
| 后端模式切换 | 支持 IPC 插件模式 / 远端 API 模式 |
| macOS WebSocket 自动探测 | 支持 |
@@ -178,9 +179,12 @@ flowchart LR
Service --> Tooling["工具调用模拟"]
Service --> Model["模型探测"]
Service --> Recorder["请求 / 日志记录"]
Service --> Images["图片路由"]
Service --> Backend{"后端模式"}
Backend --> Transport["IPC 插件传输层"]
Backend --> Remote["远端 API 客户端"]
Images -->|"有图请求"| Transport
Images -->|"图片 + 工具：提取图片上下文"| Remote
Transport --> Pipe["Windows Named Pipe"]
Transport --> WS["WebSocket"]
Pipe --> Lingma["通义灵码 IDE 插件"]
@@ -231,18 +235,18 @@ flowchart LR
CLI 也可以手动指定：
```bash
lingma-ipc-proxy --transport websocket --ws-url ws://127.0.0.1:36510 --port 8095
lingma-ipc-proxy --transport pipe --pipe '\\.\pipe\lingma-ipc'
lingma-proxy --transport websocket --ws-url ws://127.0.0.1:36510 --port 8095
lingma-proxy --transport pipe --pipe '\\.\pipe\lingma-ipc'
```
## 后端模式
### 远端 API 模式（默认，实验）
### 远端 API 模式（默认，推荐）
远端模式直接调用 Lingma 远端接口：
```bash
lingma-ipc-proxy --backend remote --port 8095
lingma-proxy --backend remote --port 8095
```
默认会只读导入：
@@ -259,10 +263,10 @@ lingma-ipc-proxy --backend remote --port 8095
也可以指定显式凭据文件：
```bash
lingma-ipc-proxy \
lingma-proxy \
--backend remote \
--remote-base-url https://lingma.alibabacloud.com \
--remote-auth-file ~/.config/lingma-ipc-proxy/credentials.json
--remote-auth-file ~/.config/lingma-proxy/credentials.json
```
`credentials.json` 格式：
@@ -282,10 +286,12 @@ lingma-ipc-proxy \
说明：
- 远端 API 模式是日常 Agent 使用的默认推荐模式。它绕过 IDE / 插件 IPC 运行时，因此更少受到插件会话、IDE 当前项目和本地扩展环境限制影响。
- 远端模式不会写入或迁移你的登录态，只会读取本机 Lingma 缓存或你指定的凭据文件。
- 如果 Lingma 插件配置过专属域名，远端模式会优先使用 `--remote-base-url`、`LINGMA_REMOTE_BASE_URL` 或配置文件；这些为空时，会扫描 macOS、Windows、Linux 上 Lingma 本地日志里的 `endpoint config:`、Marketplace service URL 等线索。
- 桌面端设置页会展示当前解析到的远端域名和来源，但不会展示 token / key 明文。
- 远端模式的 `/v1/models` 返回的是远端接口模型 key，不一定等同于 IPC 插件模式里看到的 `MiniMax-M2.7`、`Kimi-K2.6` 等展示名。
- 远端模式下的图片请求会自动走 IPC 图片链路，因为直连远端聊天接口不会直接消费本地 `file://` 和 data URL 图片。若请求同时带工具，代理会先通过 IPC 提取图片上下文，再把不含图片但包含上下文的请求交给 Remote API 原生工具调用。
- 当前本机实测：`/health`、`/v1/models`、OpenAI 流式 / 非流式、Claude Code Anthropic + Bash 工具调用均可用；Claude Code 完整工具链耗时明显高于简单 OpenAI 请求。
- 该模式参考了 [ZipperCode/lingma2api](https://github.com/ZipperCode/lingma2api) 对 Lingma 远端接口、签名和登录态结构的探索，本仓库将其作为可切换后端集成到现有 OpenAI / Anthropic / 桌面 App 架构中。
@@ -294,10 +300,10 @@ lingma-ipc-proxy \
IPC 模式通过本机 Lingma IDE 插件通信：
```bash
lingma-ipc-proxy --backend ipc --transport auto --port 8095
lingma-proxy --backend ipc --transport auto --port 8095
```
适合已经打开 VS Code / Lingma 插件、希望使用插件当前会话环境、并优先使用插件探测模型列表的场景。
适合已经打开 VS Code / Lingma 插件、希望使用插件当前会话环境、并优先使用插件探测模型列表的场景。相比远端 API 模式，IPC 插件模式更依赖 IDE / 插件进程，也更容易受到插件会话、当前项目和本地环境的影响。
## 快速开始
@@ -310,8 +316,8 @@ lingma-ipc-proxy --backend ipc --transport auto --port 8095
### 使用桌面 App
1. 前往 [Releases](https://github.com/Lutiancheng1/lingma-ipc-proxy/releases) 下载桌面版。
2. macOS 解压后打开 `Lingma IPC Proxy.app`。
1. 前往 [Releases](https://github.com/Lutiancheng1/lingma-proxy/releases) 下载桌面版。
2. macOS 解压后打开 `Lingma Proxy.app`。
3. Windows 解压后运行桌面版 exe。
4. 点击启动代理。
5. 点击 `探测模型`。
@@ -319,24 +325,68 @@ lingma-ipc-proxy --backend ipc --transport auto --port 8095
### 使用 CLI
macOS：
直接从源码运行：
```bash
git clone https://github.com/Lutiancheng1/lingma-ipc-proxy.git
cd lingma-ipc-proxy
go build -o ./dist/lingma-ipc-proxy ./cmd/lingma-ipc-proxy
./dist/lingma-ipc-proxy --host 127.0.0.1 --port 8095 --session-mode auto
git clone https://github.com/Lutiancheng1/lingma-proxy.git
cd lingma-proxy
go run ./cmd/lingma-ipc-proxy --host 127.0.0.1 --port 8095 --session-mode auto
```
只有在你明确需要二进制文件时再构建：
```bash
go build -o ./dist/lingma-proxy ./cmd/lingma-ipc-proxy
./dist/lingma-proxy --host 127.0.0.1 --port 8095 --session-mode auto
```
Windows：
```powershell
git clone https://github.com/Lutiancheng1/lingma-ipc-proxy.git
cd lingma-ipc-proxy
git clone https://github.com/Lutiancheng1/lingma-proxy.git
cd lingma-proxy
.\scripts\build.ps1
.\dist\lingma-ipc-proxy.exe --host 127.0.0.1 --port 8095 --session-mode auto
.\dist\lingma-proxy.exe --host 127.0.0.1 --port 8095 --session-mode auto
```
### 无 CI 的服务器源码部署
如果你不想在本地交叉编译 Linux 二进制，可以把 `vendor/` 一起提交，然后让目标服务器直接从源码构建：
```bash
go mod vendor
REMOTE_HOST=150.158.105.6 \
REMOTE_USER=root \
REMOTE_PASSWORD='your-password' \
./scripts/deploy-remote.sh
```
脚本会上传 `cmd/`、`internal/`、`vendor/`、`go.mod` 和 `go.sum`，在服务器上准备 Docker 构建上下文，然后用多阶段 Docker build 重建运行时镜像。远端主机需要预装 `docker`、`tar`、`curl`；不需要额外安装宿主机 Go，但如果相关基础镜像未缓存，仍需要能拉取 Docker 基础镜像。
### API 鉴权
可以通过环境变量 `LINGMA_PROXY_API_KEYS` 或 JSON 配置里的 `api_keys` 设置一个或多个 API Key：
```bash
export LINGMA_PROXY_API_KEYS="key-one,key-two"
go run ./cmd/lingma-ipc-proxy --host 127.0.0.1 --port 8095
```
```json
{
"api_keys": ["key-one", "key-two"]
}
```
部署脚本也会透传 `LINGMA_PROXY_API_KEYS`，所以可以在远端部署时一起启用同一组 key。
配置了 key 之后，除 `/`、`/health`、`/runtime/status`、`/v1/runtime/status` 之外的接口都会要求鉴权。客户端可以使用：
- `Authorization: Bearer <key>`
- `x-api-key: <key>`
这也兼容大多数 OpenAI 兼容客户端自带的 API Key 配置方式。
## 客户端配置
### Claude Code
@@ -408,7 +458,7 @@ export ANTHROPIC_API_KEY="any"
当客户端请求没有携带 `model` 字段时，代理默认使用：`kmodel`（远端模型列表里的 Kimi-K2.6）。
远端模式默认开启超时兜底。遇到请求超时、上游 5xx/429 或网络中断时，代理只会在尚未向客户端输出任何流式内容的情况下切换模型。兜底候选会先和实际 `/v1/models` 返回结果求交集，不存在或当前账号不可用的模型会自动跳过。默认顺序：
远端模式默认开启兜底。代理默认请求超时为 `0`，表示 Lingma Proxy 不设置自己的单次请求 deadline，适合长流程 Agent 任务。如果你把 `"timeout"` 设置为正数秒，超时错误也会触发兜底。上游 5xx/429 或网络中断不受超时设置影响，仍可触发兜底；但代理只会在尚未向客户端输出任何流式内容的情况下切换模型。兜底候选会先和实际 `/v1/models` 返回结果求交集，不存在或当前账号不可用的模型会自动跳过。默认顺序：
`Kimi-K2.6 -> MiniMax-M2.7 -> Qwen3-Coder -> Qwen3.6-Plus -> Qwen3-Max -> Qwen3-Thinking`
@@ -417,6 +467,7 @@ export ANTHROPIC_API_KEY="any"
默认读取：
```text
./lingma-proxy.json
./lingma-ipc-proxy.json
```
@@ -434,7 +485,7 @@ export ANTHROPIC_API_KEY="any"
"mode": "agent",
"shell_type": "zsh",
"session_mode": "auto",
"timeout": 300,
"timeout": 0,
"remote_fallback_enabled": true,
"remote_fallback_models": [
"kmodel",
@@ -475,7 +526,7 @@ export ANTHROPIC_API_KEY="any"
示例：
```bash
LINGMA_PROXY_MAX_CONCURRENT=8 lingma-ipc-proxy --port 8095
LINGMA_PROXY_MAX_CONCURRENT=8 lingma-proxy --port 8095
```
## 工具调用实现
@@ -559,10 +610,10 @@ wails build -platform windows/amd64 -clean
桌面端最终 App 名称统一为：
```text
Lingma IPC Proxy
Lingma Proxy
```
不会再生成 `lingma-proxy-desktop` 旧包名。
Release 资产文件名仍使用 `lingma-proxy-desktop_<tag>_...` 区分桌面端和 CLI 端。
## GitHub Actions Release
@@ -587,9 +638,9 @@ Release workflow 会执行：
## 与上游项目的关系
我对比了上游仓库 [coolxll/lingma-ipc-proxy](https://github.com/coolxll/lingma-ipc-proxy)。上游项目的核心贡献是发现并验证了 Lingma 本地私有 IPC 协议可以被代理成标准 HTTP API，这是本项目的基础思路来源。
我对比了上游仓库 [coolxll/lingma-ipc-proxy](https://github.com/coolxll/lingma-ipc-proxy)。上游项目的核心贡献是发现并验证了 Lingma 本地私有 IPC 协议可以被代理成标准 HTTP API，这是本项目 **IPC 插件模式** 的基础思路来源。
本项目在这个思路上继续扩展了：
本项目在 IPC 插件模式上继续扩展了：
- 更完整的 OpenAI / Anthropic 参数兼容
- Tools / Function Calling 模拟
@@ -614,4 +665,4 @@ Release workflow 会执行：
## 致谢
本项目的协议实现思路参考并继承自 [coolxll/lingma-ipc-proxy](https://github.com/coolxll/lingma-ipc-proxy) 的协议发现工作。Lingma 私有本地 IPC 可以被转换为标准 OpenAI / Anthropic API 这一核心思想是该项目首先验证出来的；本项目在此基础上补充了更完整的协议兼容、工具调用、图片处理、桌面 App、请求 / 日志观测、跨平台打包和 release 自动化。
本项目的 **IPC 插件模式** 参考并继承自 [coolxll/lingma-ipc-proxy](https://github.com/coolxll/lingma-ipc-proxy) 的协议发现工作。Lingma 私有本地 IPC 可以被转换为标准 OpenAI / Anthropic API 这一核心思想是该项目首先验证出来的；Lingma Proxy 保留这条 IPC 路径作为兼容后端，并补充了更完整的协议兼容、工具调用、图片处理、桌面 App、请求 / 日志观测、跨平台打包和 release 自动化。默认推荐的 **远端 API 模式** 是独立后端，直接调用 Lingma 远端 API，上文已单独说明。

144
cmd/lingma-ipc-proxy/main.go
View File

@@ -31,6 +31,7 @@ type fileConfig struct {
RemoteBaseURL string `json:"remote_base_url"`
RemoteAuthFile string `json:"remote_auth_file"`
RemoteVersion string `json:"remote_version"`
APIKeys []string `json:"api_keys"`
Cwd string `json:"cwd"`
CurrentFilePath string `json:"current_file_path"`
Mode string `json:"mode"`
@@ -40,6 +41,18 @@ type fileConfig struct {
TimeoutSeconds int `json:"timeout"`
RemoteFallbackEnabled *bool `json:"remote_fallback_enabled"`
RemoteFallbackModels []string `json:"remote_fallback_models"`
LingmaBootstrapEnabled *bool `json:"lingma_bootstrap_enabled"`
LingmaSourceType string `json:"lingma_source_type"`
LingmaVSIXURL string `json:"lingma_vsix_url"`
LingmaMarketplacePublisher string `json:"lingma_marketplace_publisher"`
LingmaMarketplaceExtension string `json:"lingma_marketplace_extension"`
LingmaBootstrapOutputDir string `json:"lingma_bootstrap_output_dir"`
LingmaBinaryPath string `json:"lingma_binary_path"`
LingmaBootstrapAlways *bool `json:"lingma_bootstrap_always"`
LingmaForceRefresh *bool `json:"lingma_force_refresh"`
LingmaWorkDir string `json:"lingma_work_dir"`
LingmaSessionBundle string `json:"lingma_session_bundle"`
LingmaSessionBundleFile string `json:"lingma_session_bundle_file"`
}
func main() {
@@ -47,6 +60,9 @@ func main() {
addr := fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)
svc := service.New(cfg)
if err := svc.PrepareRuntime(); err != nil {
log.Fatalf("prepare runtime: %v", err)
}
warmupCtx, warmupCancel := context.WithTimeout(context.Background(), 10*time.Second)
if err := svc.Warmup(warmupCtx); err != nil {
log.Printf("warmup failed: %v", err)
@@ -57,7 +73,7 @@ func main() {
server := httpapi.NewServer(addr, svc)
log.Printf("lingma-ipc-proxy listening on http://%s", addr)
log.Printf("lingma-proxy listening on http://%s", addr)
log.Printf("session mode: %s", cfg.SessionMode)
log.Printf("transport: %s", cfg.Transport)
log.Printf("mode: %s", cfg.Mode)
@@ -100,9 +116,13 @@ func loadConfig() (service.Config, string) {
Model: "kmodel",
ShellType: defaultShellType(),
SessionMode: service.SessionModeAuto,
Timeout: 300 * time.Second,
Timeout: 0,
RemoteFallbackEnabled: true,
RemoteFallbackModels: service.DefaultRemoteFallbackModels(),
LingmaBootstrapEnabled: false,
LingmaSourceType: "marketplace",
LingmaBootstrapAlways: true,
LingmaForceRefresh: false,
}
configPath, configLoaded := resolveConfigPath()
@@ -125,16 +145,29 @@ func loadConfig() (service.Config, string) {
remoteBaseURL := flag.String("remote-base-url", cfg.RemoteBaseURL, "Remote Lingma API base URL")
remoteAuthFile := flag.String("remote-auth-file", cfg.RemoteAuthFile, "Remote Lingma credentials.json path; empty reads ~/.lingma cache")
remoteVersion := flag.String("remote-version", cfg.RemoteVersion, "Remote Lingma cosy version")
apiKeys := flag.String("api-keys", strings.Join(cfg.APIKeys, ","), "Comma-separated API keys accepted via Authorization Bearer or x-api-key")
cwd := flag.String("cwd", cfg.Cwd, "Working directory used when creating Lingma sessions")
currentFilePath := flag.String("current-file-path", cfg.CurrentFilePath, "Current file path sent through ACP meta")
mode := flag.String("mode", cfg.Mode, "Lingma ACP mode value")
model := flag.String("model", cfg.Model, "Default Lingma model when API request omits model")
shellType := flag.String("shell-type", cfg.ShellType, "Shell type sent through ACP meta")
timeoutSeconds := flag.Int("timeout", int(cfg.Timeout/time.Second), "Per-request timeout in seconds")
timeoutSeconds := flag.Int("timeout", int(cfg.Timeout/time.Second), "Per-request timeout in seconds; 0 disables the proxy deadline")
remoteFallbackEnabled := flag.Bool("remote-fallback", cfg.RemoteFallbackEnabled, "Enable remote timeout/5xx fallback to the next available model")
remoteFallbackModels := flag.String("remote-fallback-models", strings.Join(cfg.RemoteFallbackModels, ","), "Comma-separated remote fallback model IDs")
sessionMode := flag.String("session-mode", string(cfg.SessionMode), "Session mode: auto, fresh, reuse")
config := flag.String("config", valueOr(configPath, filepath.Join(currentDir(), "lingma-ipc-proxy.json")), "Path to JSON config file")
lingmaBootstrap := flag.Bool("lingma-bootstrap", cfg.LingmaBootstrapEnabled, "Download/extract Lingma runtime assets before startup")
lingmaSourceType := flag.String("lingma-source-type", cfg.LingmaSourceType, "Lingma bootstrap source: marketplace or vsix")
lingmaVSIXURL := flag.String("lingma-vsix-url", cfg.LingmaVSIXURL, "Lingma VSIX URL used when bootstrap source is vsix or marketplace fallback")
lingmaMarketplacePublisher := flag.String("lingma-marketplace-publisher", cfg.LingmaMarketplacePublisher, "VS Code marketplace publisher for Lingma bootstrap")
lingmaMarketplaceExtension := flag.String("lingma-marketplace-extension", cfg.LingmaMarketplaceExtension, "VS Code marketplace extension name for Lingma bootstrap")
lingmaBootstrapOutputDir := flag.String("lingma-bootstrap-output-dir", cfg.LingmaBootstrapOutputDir, "Lingma bootstrap release output directory")
lingmaBinaryPath := flag.String("lingma-binary-path", cfg.LingmaBinaryPath, "Lingma binary output path")
lingmaBootstrapAlways := flag.Bool("lingma-bootstrap-always", cfg.LingmaBootstrapAlways, "Re-check bootstrap source at startup")
lingmaForceRefresh := flag.Bool("lingma-force-refresh", cfg.LingmaForceRefresh, "Force refresh Lingma bootstrap assets")
lingmaWorkDir := flag.String("lingma-work-dir", cfg.LingmaWorkDir, "Lingma work/cache directory used for restored session bundles")
lingmaSessionBundle := flag.String("lingma-session-bundle", cfg.LingmaSessionBundle, "Base64 tar.gz Lingma session bundle to restore before startup")
lingmaSessionBundleFile := flag.String("lingma-session-bundle-file", cfg.LingmaSessionBundleFile, "File containing a base64 tar.gz Lingma session bundle")
config := flag.String("config", valueOr(configPath, filepath.Join(currentDir(), "lingma-proxy.json")), "Path to JSON config file")
flag.Parse()
parsedSessionMode := parseSessionMode(*sessionMode)
@@ -150,6 +183,7 @@ func loadConfig() (service.Config, string) {
cfg.RemoteBaseURL = strings.TrimSpace(*remoteBaseURL)
cfg.RemoteAuthFile = strings.TrimSpace(*remoteAuthFile)
cfg.RemoteVersion = strings.TrimSpace(*remoteVersion)
cfg.APIKeys = splitCSV(*apiKeys)
cfg.Cwd = strings.TrimSpace(*cwd)
cfg.CurrentFilePath = strings.TrimSpace(*currentFilePath)
cfg.Mode = strings.TrimSpace(*mode)
@@ -159,6 +193,18 @@ func loadConfig() (service.Config, string) {
cfg.Timeout = time.Duration(*timeoutSeconds) * time.Second
cfg.RemoteFallbackEnabled = *remoteFallbackEnabled
cfg.RemoteFallbackModels = splitCSV(*remoteFallbackModels)
cfg.LingmaBootstrapEnabled = *lingmaBootstrap
cfg.LingmaSourceType = strings.TrimSpace(*lingmaSourceType)
cfg.LingmaVSIXURL = strings.TrimSpace(*lingmaVSIXURL)
cfg.LingmaMarketplacePublisher = strings.TrimSpace(*lingmaMarketplacePublisher)
cfg.LingmaMarketplaceExtension = strings.TrimSpace(*lingmaMarketplaceExtension)
cfg.LingmaBootstrapOutputDir = strings.TrimSpace(*lingmaBootstrapOutputDir)
cfg.LingmaBinaryPath = strings.TrimSpace(*lingmaBinaryPath)
cfg.LingmaBootstrapAlways = *lingmaBootstrapAlways
cfg.LingmaForceRefresh = *lingmaForceRefresh
cfg.LingmaWorkDir = strings.TrimSpace(*lingmaWorkDir)
cfg.LingmaSessionBundle = strings.TrimSpace(*lingmaSessionBundle)
cfg.LingmaSessionBundleFile = strings.TrimSpace(*lingmaSessionBundleFile)
if configLoaded {
configPath = finalConfigPath
@@ -176,9 +222,11 @@ func resolveConfigPath() (string, bool) {
if path := strings.TrimSpace(os.Getenv("LINGMA_PROXY_CONFIG")); path != "" {
return path, true
}
defaultPath := filepath.Join(currentDir(), "lingma-ipc-proxy.json")
if info, err := os.Stat(defaultPath); err == nil && !info.IsDir() {
return defaultPath, true
defaultPath := filepath.Join(currentDir(), "lingma-proxy.json")
for _, candidate := range []string{defaultPath, filepath.Join(currentDir(), "lingma-ipc-proxy.json")} {
if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
return candidate, true
}
}
return defaultPath, false
}
@@ -223,6 +271,9 @@ func overlayFileConfig(dst *service.Config, src fileConfig) {
if strings.TrimSpace(src.RemoteVersion) != "" {
dst.RemoteVersion = strings.TrimSpace(src.RemoteVersion)
}
if len(src.APIKeys) > 0 {
dst.APIKeys = cleanStringSlice(src.APIKeys)
}
if strings.TrimSpace(src.Cwd) != "" {
dst.Cwd = strings.TrimSpace(src.Cwd)
}
@@ -241,7 +292,7 @@ func overlayFileConfig(dst *service.Config, src fileConfig) {
if strings.TrimSpace(src.SessionMode) != "" {
dst.SessionMode = parseSessionMode(src.SessionMode)
}
if src.TimeoutSeconds > 0 {
if src.TimeoutSeconds >= 0 {
dst.Timeout = time.Duration(src.TimeoutSeconds) * time.Second
}
if src.RemoteFallbackEnabled != nil {
@@ -250,6 +301,42 @@ func overlayFileConfig(dst *service.Config, src fileConfig) {
if len(src.RemoteFallbackModels) > 0 {
dst.RemoteFallbackModels = cleanStringSlice(src.RemoteFallbackModels)
}
if src.LingmaBootstrapEnabled != nil {
dst.LingmaBootstrapEnabled = *src.LingmaBootstrapEnabled
}
if strings.TrimSpace(src.LingmaSourceType) != "" {
dst.LingmaSourceType = strings.TrimSpace(src.LingmaSourceType)
}
if strings.TrimSpace(src.LingmaVSIXURL) != "" {
dst.LingmaVSIXURL = strings.TrimSpace(src.LingmaVSIXURL)
}
if strings.TrimSpace(src.LingmaMarketplacePublisher) != "" {
dst.LingmaMarketplacePublisher = strings.TrimSpace(src.LingmaMarketplacePublisher)
}
if strings.TrimSpace(src.LingmaMarketplaceExtension) != "" {
dst.LingmaMarketplaceExtension = strings.TrimSpace(src.LingmaMarketplaceExtension)
}
if strings.TrimSpace(src.LingmaBootstrapOutputDir) != "" {
dst.LingmaBootstrapOutputDir = strings.TrimSpace(src.LingmaBootstrapOutputDir)
}
if strings.TrimSpace(src.LingmaBinaryPath) != "" {
dst.LingmaBinaryPath = strings.TrimSpace(src.LingmaBinaryPath)
}
if src.LingmaBootstrapAlways != nil {
dst.LingmaBootstrapAlways = *src.LingmaBootstrapAlways
}
if src.LingmaForceRefresh != nil {
dst.LingmaForceRefresh = *src.LingmaForceRefresh
}
if strings.TrimSpace(src.LingmaWorkDir) != "" {
dst.LingmaWorkDir = strings.TrimSpace(src.LingmaWorkDir)
}
if strings.TrimSpace(src.LingmaSessionBundle) != "" {
dst.LingmaSessionBundle = strings.TrimSpace(src.LingmaSessionBundle)
}
if strings.TrimSpace(src.LingmaSessionBundleFile) != "" {
dst.LingmaSessionBundleFile = strings.TrimSpace(src.LingmaSessionBundleFile)
}
}
func overlayEnvConfig(dst *service.Config) {
@@ -280,6 +367,9 @@ func overlayEnvConfig(dst *service.Config) {
if value := strings.TrimSpace(os.Getenv("LINGMA_REMOTE_VERSION")); value != "" {
dst.RemoteVersion = value
}
if value := strings.TrimSpace(os.Getenv("LINGMA_PROXY_API_KEYS")); value != "" {
dst.APIKeys = splitCSV(value)
}
if value := strings.TrimSpace(os.Getenv("LINGMA_PROXY_CWD")); value != "" {
dst.Cwd = value
}
@@ -298,7 +388,7 @@ func overlayEnvConfig(dst *service.Config) {
if value := strings.TrimSpace(os.Getenv("LINGMA_PROXY_SESSION_MODE")); value != "" {
dst.SessionMode = parseSessionMode(value)
}
if value := envInt("LINGMA_PROXY_TIMEOUT_SECONDS", 0); value > 0 {
if value := envInt("LINGMA_PROXY_TIMEOUT_SECONDS", -1); value >= 0 {
dst.Timeout = time.Duration(value) * time.Second
}
if value, ok := envBool("LINGMA_REMOTE_FALLBACK_ENABLED"); ok {
@@ -307,6 +397,42 @@ func overlayEnvConfig(dst *service.Config) {
if value := strings.TrimSpace(os.Getenv("LINGMA_REMOTE_FALLBACK_MODELS")); value != "" {
dst.RemoteFallbackModels = splitCSV(value)
}
if value, ok := envBool("LINGMA_BOOTSTRAP_ENABLED"); ok {
dst.LingmaBootstrapEnabled = value
}
if value := strings.TrimSpace(os.Getenv("LINGMA_SOURCE_TYPE")); value != "" {
dst.LingmaSourceType = value
}
if value := strings.TrimSpace(os.Getenv("LINGMA_VSIX_URL")); value != "" {
dst.LingmaVSIXURL = value
}
if value := strings.TrimSpace(os.Getenv("LINGMA_MARKETPLACE_PUBLISHER")); value != "" {
dst.LingmaMarketplacePublisher = value
}
if value := strings.TrimSpace(os.Getenv("LINGMA_MARKETPLACE_EXTENSION")); value != "" {
dst.LingmaMarketplaceExtension = value
}
if value := strings.TrimSpace(os.Getenv("LINGMA_BOOTSTRAP_OUTPUT_DIR")); value != "" {
dst.LingmaBootstrapOutputDir = value
}
if value := strings.TrimSpace(os.Getenv("LINGMA_BIN")); value != "" {
dst.LingmaBinaryPath = value
}
if value, ok := envBool("LINGMA_BOOTSTRAP_ALWAYS"); ok {
dst.LingmaBootstrapAlways = value
}
if value, ok := envBool("LINGMA_FORCE_REFRESH"); ok {
dst.LingmaForceRefresh = value
}
if value := strings.TrimSpace(os.Getenv("LINGMA_WORK_DIR")); value != "" {
dst.LingmaWorkDir = value
}
if value := strings.TrimSpace(os.Getenv("LINGMA_SESSION_BUNDLE")); value != "" {
dst.LingmaSessionBundle = value
}
if value := strings.TrimSpace(os.Getenv("LINGMA_SESSION_BUNDLE_FILE")); value != "" {
dst.LingmaSessionBundleFile = value
}
}
func parseSessionMode(value string) service.SessionMode {

19
config.example.json
View File

@@ -20,5 +20,22 @@
"shell_type": "powershell",
"current_file_path": "",
"pipe": "",
"websocket_url": ""
"websocket_url": "",
"remote_auth_file": "/secrets/credentials.json",
"api_keys": [
"replace-with-long-random-key-1",
"replace-with-long-random-key-2"
],
"lingma_bootstrap_enabled": true,
"lingma_source_type": "marketplace",
"lingma_vsix_url": "",
"lingma_marketplace_publisher": "Alibaba-Cloud",
"lingma_marketplace_extension": "tongyi-lingma",
"lingma_binary_path": "/app/data/bin/Lingma",
"lingma_bootstrap_output_dir": "/app/data/bin/release",
"lingma_bootstrap_always": true,
"lingma_force_refresh": false,
"lingma_work_dir": "/app/data/.lingma/vscode/sharedClientCache",
"lingma_session_bundle": "",
"lingma_session_bundle_file": "/secrets/session.bundle"
}

39
desktop/app.go
View File

@@ -198,6 +198,11 @@ func (a *App) QuitApp() {
a.beginQuit()
}
// ForceQuitApp stops the proxy and exits the desktop process immediately.
func (a *App) ForceQuitApp() {
a.beginQuit()
}
// RequestQuitShortcut requires two shortcut presses to avoid accidental exits.
func (a *App) RequestQuitShortcut() {
now := time.Now()
@@ -226,9 +231,20 @@ func (a *App) forceQuit() {
a.mu.Unlock()
a.emitLog("info", "正在停止代理并退出应用")
done := make(chan struct{})
go func() {
if err := a.StopProxy(); err != nil {
runtime.LogWarningf(a.ctx, "stop proxy before exit failed: %v", err)
}
close(done)
}()
select {
case <-done:
case <-time.After(1200 * time.Millisecond):
runtime.LogWarning(a.ctx, "force quit continuing before proxy shutdown completed")
}
os.Exit(0)
}
@@ -358,7 +374,7 @@ func (a *App) saveConfig(cfg service.Config) error {
if err != nil {
return err
}
dir := filepath.Join(home, ".config", "lingma-ipc-proxy")
dir := filepath.Join(home, ".config", "lingma-proxy")
if err := os.MkdirAll(dir, 0755); err != nil {
return err
}
@@ -411,10 +427,10 @@ func (a *App) StartProxy() error {
warmupCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
if err := svc.Warmup(warmupCtx); err != nil {
runtime.LogWarningf(a.ctx, "warmup failed: %v", err)
a.emitLog("warn", fmt.Sprintf("Lingma IPC warmup failed: %v. %s", err, transportFallbackHint()))
a.emitLog("warn", fmt.Sprintf("%s warmup failed: %v. %s", backendLabel(cfg.Backend), err, warmupFallbackHint(cfg.Backend)))
} else {
runtime.LogInfo(a.ctx, "Lingma IPC warmup completed")
a.emitLog("info", "Lingma IPC warmup completed")
runtime.LogInfof(a.ctx, "%s warmup completed", backendLabel(cfg.Backend))
a.emitLog("info", fmt.Sprintf("%s warmup completed", backendLabel(cfg.Backend)))
}
cancel()
@@ -906,7 +922,7 @@ func defaultConfig() service.Config {
Model: "kmodel",
ShellType: defaultShellType(),
SessionMode: service.SessionModeAuto,
Timeout: 300 * time.Second,
Timeout: 0,
RemoteFallbackEnabled: true,
RemoteFallbackModels: service.DefaultRemoteFallbackModels(),
}
@@ -984,7 +1000,7 @@ func defaultConfig() service.Config {
if fileCfg.SessionMode != "" {
cfg.SessionMode = service.SessionMode(fileCfg.SessionMode)
}
if fileCfg.TimeoutSeconds > 0 {
if fileCfg.TimeoutSeconds >= 0 {
cfg.Timeout = time.Duration(fileCfg.TimeoutSeconds) * time.Second
}
if fileCfg.RemoteFallbackEnabled != nil {
@@ -1041,15 +1057,19 @@ func configSearchPaths() []string {
var paths []string
// 1. Executable directory (for dev / portable mode)
if exe, err := os.Executable(); err == nil {
paths = append(paths, filepath.Join(filepath.Dir(exe), "lingma-proxy.json"))
paths = append(paths, filepath.Join(filepath.Dir(exe), "lingma-ipc-proxy.json"))
}
// 2. Current working directory
if wd, err := os.Getwd(); err == nil {
paths = append(paths, filepath.Join(wd, "lingma-proxy.json"))
paths = append(paths, filepath.Join(wd, "lingma-ipc-proxy.json"))
}
// 3. User home directory
if home, err := os.UserHomeDir(); err == nil {
paths = append(paths, filepath.Join(home, "lingma-proxy.json"))
paths = append(paths, filepath.Join(home, "lingma-ipc-proxy.json"))
paths = append(paths, filepath.Join(home, ".config", "lingma-proxy", "config.json"))
paths = append(paths, filepath.Join(home, ".config", "lingma-ipc-proxy", "config.json"))
}
return paths
@@ -1075,5 +1095,12 @@ func defaultShellType() string {
}
func transportFallbackHint() string {
return "请确认 Lingma 插件已启动并登录；如果自动探测失败，请到设置页手动填写：远端 API 官方默认域名 https://lingma.alibabacloud.com，企业版请填写你的专属域名；macOS WebSocket 示例 ws://127.0.0.1:36510/，Windows Named Pipe 示例 \\\\.\\pipe\\lingma-xxxx，或 Windows WebSocket 示例 ws://127.0.0.1:36510/。"
}
func warmupFallbackHint(backend service.BackendMode) string {
if backend == service.BackendRemote {
return "请检查设置页“当前解析结果”里的远端域名是否为官方或企业专属 API 域名；如果出现 OSS/静态资源域名或模型列表 404，请手动填写远端 API 官方默认域名 https://lingma.alibabacloud.com，企业版请填写你的专属域名，并确认登录态未过期。"
}
return "请确认 Lingma 插件已启动并登录；如果自动探测失败，请到设置页手动填写：macOS WebSocket 示例 ws://127.0.0.1:36510/，Windows Named Pipe 示例 \\\\.\\pipe\\lingma-xxxx，或 Windows WebSocket 示例 ws://127.0.0.1:36510/。"
}

2
desktop/frontend/index.html
View File

@@ -4,7 +4,7 @@
<meta charset="UTF-8"/>
<meta content="width=device-width, initial-scale=1.0" name="viewport"/>
<link rel="icon" type="image/png" href="/favicon.png"/>
<title>lingma-proxy-desktop</title>
<title>Lingma Proxy</title>
</head>
<body>
<div id="app"></div>

22
desktop/frontend/src/App.vue
View File

@@ -6,7 +6,7 @@ import Models from './views/Models.vue'
import Requests from './views/Requests.vue'
import Settings from './views/Settings.vue'
import { EventsOff, EventsOn } from '../wailsjs/runtime'
import { ClearLogs, GetLogs, GetStatus, HideWindow, MinimizeWindow } from '../wailsjs/go/main/App.js'
import { ClearLogs, ForceQuitApp, GetLogs, GetStatus, HideWindow, MinimizeWindow } from '../wailsjs/go/main/App.js'
import lingmaIcon from './assets/images/lingma-icon.png'
const currentTab = ref('dashboard')
@@ -15,6 +15,7 @@ const status = ref({ running: false, addr: '', models: 0 })
const toast = ref('')
const themeMode = ref(localStorage.getItem('lingma-theme-mode') || 'system')
const appliedTheme = ref('light')
const forceQuitting = ref(false)
let systemThemeQuery = null
let toastTimer = null
@@ -105,6 +106,18 @@ async function copyEndpoint() {
handleNotice('已复制接口地址：' + value)
}
async function forceQuitApp() {
if (forceQuitting.value) return
forceQuitting.value = true
showToast('正在停止代理并退出应用...')
try {
await ForceQuitApp()
} catch (e) {
forceQuitting.value = false
addLog('error', '退出应用失败：' + (e.message || String(e)))
}
}
function safeEventsOn(name, handler) {
try {
EventsOn(name, handler)
@@ -215,7 +228,7 @@ onUnmounted(() => {
</span>
<span>
<strong>灵码代理</strong>
<small>IPC Proxy</small>
<small>Proxy</small>
</span>
</button>
@@ -239,7 +252,7 @@ onUnmounted(() => {
<span class="status-dot" :class="{ running: status.running }"></span>
<div>
<strong>{{ status.running ? 'Proxy Running' : 'Proxy Stopped' }}</strong>
<small>v1.4.4</small>
<small>v1.4.9</small>
</div>
</div>
</aside>
@@ -260,6 +273,9 @@ onUnmounted(() => {
<button class="icon-button" type="button" :title="themeTitle()" @click="toggleTheme">
<i class="bi" :class="themeIcon()" aria-hidden="true"></i>
</button>
<button class="icon-button danger-icon-button" type="button" title="停止代理并退出应用" :disabled="forceQuitting" @click="forceQuitApp">
<i class="bi bi-power" aria-hidden="true"></i>
</button>
</div>
</header>

22
desktop/frontend/src/style.css
View File

@@ -1289,6 +1289,17 @@ button {
border: 1px solid var(--line);
}
.danger-icon-button {
color: #b42318;
background: rgba(254, 226, 226, 0.72);
border-color: rgba(220, 38, 38, 0.24);
}
.danger-icon-button:hover {
color: #991b1b;
background: rgba(254, 202, 202, 0.88);
}
.primary-button:hover,
.secondary-button:hover,
.ghost-button:hover,
@@ -1963,6 +1974,17 @@ button:disabled {
background: rgba(30, 41, 59, 0.66);
}
:root[data-theme='dark'] .danger-icon-button {
color: #fecaca;
border-color: rgba(248, 113, 113, 0.32);
background: rgba(127, 29, 29, 0.42);
}
:root[data-theme='dark'] .danger-icon-button:hover {
color: #fff1f2;
background: rgba(153, 27, 27, 0.62);
}
:root[data-theme='dark'] .strip-actions {
background: rgba(15, 23, 42, 0.78);
}

2
desktop/frontend/src/views/Dashboard.vue
View File

@@ -318,7 +318,7 @@ onUnmounted(() => {
</div>
<div class="config-summary-item">
<label>超时</label>
<strong>{{ config.Timeout || 120 }} 秒</strong>
<strong>{{ config.Timeout > 0 ? `${config.Timeout} 秒` : '不限制' }}</strong>
</div>
<div class="config-summary-item span-2">
<label>工作目录</label>

23
desktop/frontend/src/views/Settings.vue
View File

@@ -10,6 +10,7 @@ const saving = ref(false)
const openSelect = ref('')
const fallbackModelsText = ref('')
const isIPCBackend = computed(() => (config.value.Backend || 'ipc') === 'ipc')
const formattedTokenExpireAt = computed(() => formatDateTime(detection.value?.remoteTokenExpireAt))
const selectOptions = {
Backend: [
@@ -53,6 +54,21 @@ function chooseOption(field, value) {
refreshDetection()
}
function formatDateTime(value) {
if (!value) return ''
const date = new Date(value)
if (Number.isNaN(date.getTime())) return value
return new Intl.DateTimeFormat('zh-CN', {
year: 'numeric',
month: '2-digit',
day: '2-digit',
hour: '2-digit',
minute: '2-digit',
second: '2-digit',
hour12: false,
}).format(date)
}
onMounted(async () => {
try {
config.value = await GetConfig()
@@ -163,12 +179,13 @@ async function save() {
</div>
<div class="field">
<label>超时秒数</label>
<input v-model.number="config.Timeout" type="number" min="1" />
<input v-model.number="config.Timeout" type="number" min="0" />
<small>0 表示不设置代理层单次请求超时，适合长流程任务。</small>
</div>
<div class="field span-2 switch-field">
<div>
<label>远端超时兜底</label>
<p>远端 API 超时、限流或 5xx 且尚未流式输出时，自动切换到下一个可用模型。</p>
<p>设置正数超时后，远端 API 超时、限流或 5xx 且尚未流式输出时，自动切换到下一个可用模型。</p>
</div>
<label class="switch">
<input v-model="config.RemoteFallbackEnabled" type="checkbox" />
@@ -245,7 +262,7 @@ async function save() {
<div v-if="detection.remoteCredentialSuccess">
<dt>登录态有效期</dt>
<dd :class="{ 'warn-text': detection.remoteTokenExpired }">
{{ detection.remoteTokenExpireAt || '未提供' }}
{{ formattedTokenExpireAt || '未提供' }}
<span v-if="detection.remoteTokenExpired">（已过期）</span>
</dd>
</div>

2
desktop/frontend/wailsjs/go/main/App.d.ts vendored
View File

@@ -7,6 +7,8 @@ export function ClearLogs():Promise<void>;
export function ClearRequests():Promise<void>;
export function ForceQuitApp():Promise<void>;
export function GetConfig():Promise<service.Config>;
export function GetDetectionInfo():Promise<main.DetectionInfo>;

4
desktop/frontend/wailsjs/go/main/App.js
View File

@@ -10,6 +10,10 @@ export function ClearRequests() {
return window['go']['main']['App']['ClearRequests']();
}
export function ForceQuitApp() {
return window['go']['main']['App']['ForceQuitApp']();
}
export function GetConfig() {
return window['go']['main']['App']['GetConfig']();
}

23
desktop/main.go
View File

@@ -21,7 +21,7 @@ func main() {
enableInspector := os.Getenv("LINGMA_DESKTOP_DEBUG") == "1"
err := wails.Run(&options.App{
Title: "Lingma IPC Proxy",
Title: "Lingma Proxy",
Width: 1100,
Height: 750,
MinWidth: 900,
@@ -40,7 +40,7 @@ func main() {
OnBeforeClose: app.beforeClose,
OnDomReady: app.onDomReady,
SingleInstanceLock: &options.SingleInstanceLock{
UniqueId: "lingma-ipc-proxy-desktop",
UniqueId: "lingma-proxy-desktop",
OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
},
Bind: []interface{}{
@@ -57,8 +57,8 @@ func main() {
HideToolbarSeparator: true,
},
About: &mac.AboutInfo{
Title: "Lingma IPC Proxy",
Message: "A desktop GUI for lingma-ipc-proxy",
Title: "Lingma Proxy",
Message: "A desktop GUI for Lingma Proxy",
},
},
})
@@ -86,21 +86,12 @@ func appMenu(app *App) *menu.Menu {
app.MinimizeWindow()
})
appMenu.AddSeparator()
appMenu.AddText("退出 Lingma IPC Proxy", quitAccelerator, func(_ *menu.CallbackData) {
appMenu.AddText("退出 Lingma Proxy", quitAccelerator, func(_ *menu.CallbackData) {
app.RequestQuitShortcut()
})
editMenu := menu.NewMenu()
editMenu.AddText("撤销", keys.CmdOrCtrl("z"), func(_ *menu.CallbackData) {})
editMenu.AddText("重做", keys.CmdOrCtrl("shift+z"), func(_ *menu.CallbackData) {})
editMenu.AddSeparator()
editMenu.AddText("剪切", keys.CmdOrCtrl("x"), func(_ *menu.CallbackData) {})
editMenu.AddText("复制", keys.CmdOrCtrl("c"), func(_ *menu.CallbackData) {})
editMenu.AddText("粘贴", keys.CmdOrCtrl("v"), func(_ *menu.CallbackData) {})
editMenu.AddText("全选", keys.CmdOrCtrl("a"), func(_ *menu.CallbackData) {})
return menu.NewMenuFromItems(
menu.SubMenu("Lingma IPC Proxy", appMenu),
menu.SubMenu("编辑", editMenu),
menu.SubMenu("Lingma Proxy", appMenu),
menu.EditMenu(),
)
}

4
desktop/wails.json
View File

@@ -1,6 +1,6 @@
{
"$schema": "https://wails.io/schemas/config.v2.json",
"name": "Lingma IPC Proxy",
"name": "Lingma Proxy",
"outputfilename": "LingmaProxy",
"frontend:install": "npm install",
"frontend:build": "npm run build",
@@ -11,6 +11,6 @@
"email": "lutc5@asiainfo.com"
},
"info": {
"productVersion": "1.4.4"
"productVersion": "1.4.9"
}
}

25
docker-compose.yml Normal file
View File

@@ -0,0 +1,25 @@
services:
lingma-proxy:
build:
context: .
container_name: lingma-proxy
env_file:
- .env
ports:
- "${LINGMA_PROXY_PORT:-8095}:8095"
volumes:
- ./data:/app/data
- ./secrets:/secrets:ro
restart: unless-stopped
healthcheck:
test:
[
"CMD",
"sh",
"-c",
"wget -q -O - http://127.0.0.1:8095/runtime/status | grep -q '\"ok\":true'"
]
interval: 30s
timeout: 5s
retries: 3
start_period: 20s

45
docs/architecture.md
View File

@@ -1,9 +1,9 @@
# lingma-ipc-proxy Architecture
# Lingma Proxy Architecture
This document describes the current architecture of `lingma-ipc-proxy`, including both backend modes:
This document describes the current architecture of **Lingma Proxy**, including both backend modes:
- `ipc`: bridge to the local Lingma IDE plugin transport
- `remote`: call Lingma remote HTTP APIs directly with detected credentials
- `remote`: the default and recommended mode, calling Lingma remote HTTP APIs directly with detected credentials
- `ipc`: a compatibility mode that bridges to the local Lingma IDE plugin transport
---
@@ -35,7 +35,20 @@ flowchart LR
## 2. Runtime Modes
### 2.1 IPC mode
### 2.1 Remote API mode
`backend=remote`
- Reads Lingma remote base URL from config, environment, or detected local Lingma logs
- Loads credentials from:
- explicit `remote_auth_file`
- or detected Lingma login cache
- Calls remote model list and chat endpoints directly
- Supports timeout / 429 / 5xx fallback across available remote models
- Does not use local plugin session environment knobs
- Avoids IDE/plugin IPC session lifetime, working directory, and extension environment limitations
### 2.2 IPC plugin mode
`backend=ipc`
@@ -45,18 +58,7 @@ flowchart LR
- Named Pipe on Windows
- Reuses Lingma plugin session semantics
- Session/environment options in the desktop UI apply only here
### 2.2 Remote API mode
`backend=remote`
- Reads Lingma remote base URL
- Loads credentials from:
- explicit `remote_auth_file`
- or detected Lingma cache under `~/.lingma`
- Calls remote model list and chat endpoints directly
- Supports timeout / 429 / 5xx fallback across available remote models
- Does not use local plugin session environment knobs
- This mode is based on the IPC protocol insight from `coolxll/lingma-ipc-proxy`
---
@@ -261,7 +263,8 @@ Responsibilities:
Persisted local state:
- config: `~/.config/lingma-ipc-proxy/config.json`
- config: `~/.config/lingma-proxy/config.json`
- legacy config fallback: `~/.config/lingma-ipc-proxy/config.json`
- UI/runtime state: `~/.config/lingma-ipc-proxy/app-state.json`
Production packaging rules:
@@ -277,8 +280,8 @@ Production packaging rules:
Because the two modes solve different problems:
- IPC mode preserves plugin session semantics and local tool environment
- Remote mode avoids plugin runtime coupling and is usually better for third-party agent clients
- Remote mode avoids plugin runtime coupling and is usually better for third-party agent clients.
- IPC mode preserves plugin session semantics and remains useful when the caller specifically wants the local plugin's context or model list.
### 7.2 Why keep tool emulation even with remote mode?
@@ -313,4 +316,4 @@ If you are extending the system, start here:
---
Document version: 2026-04-30
Document version: 2026-05-06

45
docs/architecture.zh-CN.md
View File

@@ -1,9 +1,9 @@
# lingma-ipc-proxy 架构文档
# Lingma Proxy 架构文档
本文档描述 `lingma-ipc-proxy` 的当前架构，覆盖两种后端模式：
本文档描述 **Lingma Proxy** 的当前架构，覆盖两种后端模式：
- `ipc`：桥接本地 Lingma IDE 插件传输层
- `remote`：直接调用 Lingma 远端 HTTP API
- `remote`：默认推荐模式，使用探测到的登录态直接调用 Lingma 远端 HTTP API
- `ipc`：兼容模式，桥接本地 Lingma IDE 插件传输层
---
@@ -35,7 +35,20 @@ flowchart LR
## 2. 运行模式
### 2.1 IPC 模式
### 2.1 Remote API 模式
`backend=remote`
- 从配置、环境变量或本地 Lingma 日志中解析远端域名
- 加载认证信息：
- 显式指定的 `remote_auth_file`
- 或自动探测 Lingma 登录缓存
- 直接请求远端模型列表和聊天接口
- 支持远端超时 / 429 / 5xx 的模型兜底切换
- 不依赖本地插件会话环境参数
- 避免 IDE / 插件 IPC 会话生命周期、工作目录和扩展环境限制
### 2.2 IPC 插件模式
`backend=ipc`
@@ -45,18 +58,7 @@ flowchart LR
- Windows：Named Pipe
- 复用 Lingma 插件自身的 session 语义
- 桌面端里“会话与环境”相关配置只在这里生效
### 2.2 Remote API 模式
`backend=remote`
- 解析远端域名
- 加载认证信息：
- 显式指定的 `remote_auth_file`
- 或自动探测 `~/.lingma` 下的缓存
- 直接请求远端模型列表和聊天接口
- 支持远端超时 / 429 / 5xx 的模型兜底切换
- 不依赖本地插件会话环境参数
- 该模式基于 `coolxll/lingma-ipc-proxy` 的 IPC 协议发现思路
---
@@ -260,7 +262,8 @@ Wails 桌面端不是简单预览壳，而是本地代理的运维控制台。
本地持久化路径：
- 配置：`~/.config/lingma-ipc-proxy/config.json`
- 配置：`~/.config/lingma-proxy/config.json`
- 旧配置兼容读取：`~/.config/lingma-ipc-proxy/config.json`
- GUI 运行状态：`~/.config/lingma-ipc-proxy/app-state.json`
打包要求：
@@ -276,8 +279,8 @@ Wails 桌面端不是简单预览壳，而是本地代理的运维控制台。
因为两种模式解决的问题不同：
- IPC 模式更贴近插件本地上下文和 session 语义
- Remote 模式更适合第三方 agent 客户端，减少对插件运行态的依赖
- Remote 模式避免插件运行时耦合，通常更适合第三方 Agent 客户端。
- IPC 模式保留插件会话语义，适合明确需要本地插件上下文或插件模型列表的场景。
### 7.2 为什么 Remote 也保留 Tool Emulation？
@@ -312,4 +315,4 @@ Wails 桌面端不是简单预览壳，而是本地代理的运维控制台。
---
文档版本：2026-04-30
文档版本：2026-05-06

BIN
docs/images/desktop-dark.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 484 KiB

After

Width:  |  Height:  |  Size: 507 KiB

BIN
docs/images/desktop-light.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 543 KiB

After

Width:  |  Height:  |  Size: 560 KiB

BIN
docs/images/desktop-narrow.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 269 KiB

After

Width:  |  Height:  |  Size: 363 KiB

476
internal/bootstrap/lingma.go Normal file
View File

@@ -0,0 +1,476 @@
package bootstrap
import (
"archive/zip"
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"path/filepath"
"runtime"
"sort"
"strings"
"time"
)
type Config struct {
Enabled bool
SourceType string
VSIXURL string
MarketplacePublisher string
MarketplaceExtension string
OutputDir string
BinaryPath string
AlwaysRefresh bool
ForceRefresh bool
HTTPTimeout time.Duration
}
type Result struct {
Enabled bool `json:"enabled"`
Source string `json:"source,omitempty"`
Version string `json:"version,omitempty"`
URL string `json:"url,omitempty"`
BinaryPath string `json:"binary_path,omitempty"`
ReleaseDir string `json:"release_dir,omitempty"`
MarkerPath string `json:"marker_path,omitempty"`
Downloaded bool `json:"downloaded"`
ReusedExisting bool `json:"reused_existing"`
Message string `json:"message,omitempty"`
}
type marker struct {
Source string `json:"source"`
URL string `json:"url"`
Version string `json:"version"`
DownloadedAt int64 `json:"downloaded_at"`
NestedZip string `json:"nested_zip"`
Member string `json:"member"`
ReleaseRoot string `json:"release_root"`
Size int `json:"size"`
Publisher string `json:"publisher,omitempty"`
Extension string `json:"extension,omitempty"`
}
func Ensure(cfg Config) (Result, error) {
result := Result{Enabled: cfg.Enabled}
if !cfg.Enabled {
result.Message = "bootstrap disabled"
return result, nil
}
cfg = normalize(cfg)
if cfg.BinaryPath == "" {
return result, fmt.Errorf("bootstrap binary path is required")
}
if err := os.MkdirAll(filepath.Dir(cfg.BinaryPath), 0o755); err != nil {
return result, err
}
if err := os.MkdirAll(cfg.OutputDir, 0o755); err != nil {
return result, err
}
resolvedURL := strings.TrimSpace(cfg.VSIXURL)
version := ""
if cfg.SourceType == "marketplace" {
url, ver, err := queryMarketplaceLatestVSIX(cfg)
if err == nil {
resolvedURL = url
version = ver
} else if resolvedURL == "" {
return result, err
}
}
if resolvedURL == "" {
return result, fmt.Errorf("bootstrap VSIX URL is empty")
}
result.Source = cfg.SourceType
result.URL = resolvedURL
result.Version = version
result.BinaryPath = cfg.BinaryPath
result.MarkerPath = filepath.Join(filepath.Dir(cfg.BinaryPath), ".lingma-bootstrap.json")
oldMarker := readMarker(result.MarkerPath)
releaseDir := releaseDirForOutput(cfg.OutputDir, oldMarker.ReleaseRoot)
result.ReleaseDir = releaseDir
ready := hasRequiredAssets(releaseDir)
if fileExists(cfg.BinaryPath) && ready && !cfg.ForceRefresh {
if !cfg.AlwaysRefresh || (version != "" && oldMarker.Version == version) {
if err := os.Chmod(cfg.BinaryPath, 0o755); err != nil {
return result, err
}
result.ReusedExisting = true
result.Message = "reused existing Lingma binary"
return result, nil
}
}
vsixBytes, err := downloadVSIX(resolvedURL, cfg.HTTPTimeout)
if err != nil {
if fileExists(cfg.BinaryPath) {
result.ReusedExisting = true
result.Message = fmt.Sprintf("download failed, reused existing Lingma: %v", err)
return result, os.Chmod(cfg.BinaryPath, 0o755)
}
return result, err
}
result.Downloaded = true
nestedName, nestedBytes, err := extractNestedZip(vsixBytes)
if err != nil {
return result, err
}
memberName, binaryBytes, releaseRoot, releaseFiles, err := extractRelease(nestedBytes)
if err != nil {
return result, err
}
releaseDir = releaseDirForOutput(cfg.OutputDir, releaseRoot)
result.ReleaseDir = releaseDir
if err := os.RemoveAll(releaseDir); err != nil {
return result, err
}
if err := writeReleaseFiles(releaseDir, releaseRoot, releaseFiles); err != nil {
return result, err
}
if err := os.WriteFile(cfg.BinaryPath, binaryBytes, 0o755); err != nil {
return result, err
}
if !hasRequiredAssets(releaseDir) {
return result, fmt.Errorf("extension assets missing after extraction under %s", releaseDir)
}
mk := marker{
Source: cfg.SourceType,
URL: resolvedURL,
Version: version,
DownloadedAt: time.Now().Unix(),
NestedZip: nestedName,
Member: memberName,
ReleaseRoot: releaseRoot,
Size: len(binaryBytes),
Publisher: cfg.MarketplacePublisher,
Extension: cfg.MarketplaceExtension,
}
if err := writeMarker(result.MarkerPath, mk); err != nil {
return result, err
}
result.Message = fmt.Sprintf("downloaded Lingma %s", versionOrUnknown(version))
return result, nil
}
type marketplaceResponse struct {
Results []struct {
Extensions []struct {
Versions []struct {
Version string `json:"version"`
Files []struct {
AssetType string `json:"assetType"`
Source string `json:"source"`
} `json:"files"`
} `json:"versions"`
} `json:"extensions"`
} `json:"results"`
}
type zipEntry struct {
Name string
Data []byte
Mode os.FileMode
}
func normalize(cfg Config) Config {
cfg.SourceType = strings.ToLower(strings.TrimSpace(cfg.SourceType))
if cfg.SourceType == "" {
cfg.SourceType = "marketplace"
}
if cfg.OutputDir == "" {
cfg.OutputDir = filepath.Join(filepath.Dir(cfg.BinaryPath), "release")
}
if cfg.HTTPTimeout <= 0 {
cfg.HTTPTimeout = 30 * time.Second
}
if strings.TrimSpace(cfg.MarketplacePublisher) == "" {
cfg.MarketplacePublisher = "Alibaba-Cloud"
}
if strings.TrimSpace(cfg.MarketplaceExtension) == "" {
cfg.MarketplaceExtension = "tongyi-lingma"
}
if strings.TrimSpace(cfg.VSIXURL) == "" {
cfg.VSIXURL = "https://tongyi-code.oss-cn-hangzhou.aliyuncs.com/vscode/tongyi-lingma-latest.vsix"
}
return cfg
}
func queryMarketplaceLatestVSIX(cfg Config) (string, string, error) {
payload := map[string]any{
"filters": []any{map[string]any{
"criteria": []any{
map[string]any{"filterType": 7, "value": cfg.MarketplacePublisher + "." + cfg.MarketplaceExtension},
map[string]any{"filterType": 8, "value": "Microsoft.VisualStudio.Code"},
},
"pageNumber": 1,
"pageSize": 1,
"sortBy": 0,
"sortOrder": 0,
}},
"assetTypes": []any{},
"flags": 950,
}
body, err := json.Marshal(payload)
if err != nil {
return "", "", err
}
req, err := http.NewRequest(http.MethodPost, "https://marketplace.visualstudio.com/_apis/public/gallery/extensionquery", bytes.NewReader(body))
if err != nil {
return "", "", err
}
req.Header.Set("accept", "application/json;api-version=3.0-preview.1")
req.Header.Set("content-type", "application/json")
req.Header.Set("x-market-client-id", "VSCode 1.115.0")
client := &http.Client{Timeout: cfg.HTTPTimeout}
resp, err := client.Do(req)
if err != nil {
return "", "", err
}
defer resp.Body.Close()
if resp.StatusCode >= 400 {
body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
return "", "", fmt.Errorf("marketplace query status %d: %s", resp.StatusCode, strings.TrimSpace(string(body)))
}
var parsed marketplaceResponse
if err := json.NewDecoder(resp.Body).Decode(&parsed); err != nil {
return "", "", err
}
if len(parsed.Results) == 0 || len(parsed.Results[0].Extensions) == 0 || len(parsed.Results[0].Extensions[0].Versions) == 0 {
return "", "", fmt.Errorf("no extension found from marketplace")
}
version := parsed.Results[0].Extensions[0].Versions[0].Version
for _, file := range parsed.Results[0].Extensions[0].Versions[0].Files {
if file.AssetType == "Microsoft.VisualStudio.Services.VSIXPackage" && strings.TrimSpace(file.Source) != "" {
return file.Source, version, nil
}
}
if version == "" {
return "", "", fmt.Errorf("no version/vsix url found from marketplace")
}
fallback := fmt.Sprintf("https://marketplace.visualstudio.com/_apis/public/gallery/publishers/%s/vsextensions/%s/%s/vspackage", cfg.MarketplacePublisher, cfg.MarketplaceExtension, version)
return fallback, version, nil
}
func downloadVSIX(url string, timeout time.Duration) ([]byte, error) {
client := &http.Client{Timeout: timeout}
resp, err := client.Get(url)
if err != nil {
return nil, fmt.Errorf("download VSIX: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode >= 400 {
body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
return nil, fmt.Errorf("download VSIX status %d: %s", resp.StatusCode, strings.TrimSpace(string(body)))
}
data, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
return data, nil
}
func extractNestedZip(vsix []byte) (string, []byte, error) {
reader, err := zip.NewReader(bytes.NewReader(vsix), int64(len(vsix)))
if err != nil {
return "", nil, err
}
candidates := make([]*zip.File, 0)
for _, file := range reader.File {
name := file.Name
if strings.HasPrefix(name, "extension/dist/bin/") && strings.HasSuffix(name, ".zip") && strings.Contains(name, "lingma-") {
candidates = append(candidates, file)
}
}
if len(candidates) == 0 {
return "", nil, fmt.Errorf("no lingma-*.zip found in VSIX")
}
sort.Slice(candidates, func(i, j int) bool { return candidates[i].Name < candidates[j].Name })
picked := candidates[len(candidates)-1]
rc, err := picked.Open()
if err != nil {
return "", nil, err
}
defer rc.Close()
data, err := io.ReadAll(rc)
if err != nil {
return "", nil, err
}
return picked.Name, data, nil
}
func extractRelease(inner []byte) (string, []byte, string, []zipEntry, error) {
reader, err := zip.NewReader(bytes.NewReader(inner), int64(len(inner)))
if err != nil {
return "", nil, "", nil, err
}
binaryPath := pickLingmaBinaryPath(reader.File)
if binaryPath == "" {
return "", nil, "", nil, fmt.Errorf("Lingma binary not found inside nested zip")
}
releaseRoot := inferReleaseRoot(binaryPath)
entries := make([]zipEntry, 0, len(reader.File))
var binaryBytes []byte
for _, file := range reader.File {
if file.FileInfo().IsDir() {
continue
}
if releaseRoot != "" && !strings.HasPrefix(file.Name, releaseRoot+"/") {
continue
}
rc, err := file.Open()
if err != nil {
return "", nil, "", nil, err
}
data, err := io.ReadAll(rc)
rc.Close()
if err != nil {
return "", nil, "", nil, err
}
entries = append(entries, zipEntry{Name: file.Name, Data: data, Mode: file.Mode()})
if file.Name == binaryPath {
binaryBytes = data
}
}
if len(binaryBytes) == 0 {
return "", nil, "", nil, fmt.Errorf("Lingma binary bytes missing from nested zip")
}
return binaryPath, binaryBytes, releaseRoot, entries, nil
}
func pickLingmaBinaryPath(files []*zip.File) string {
preferredSuffix := platformBinarySuffix()
for _, file := range files {
if strings.HasSuffix(file.Name, preferredSuffix) {
return file.Name
}
}
for _, file := range files {
if strings.HasSuffix(file.Name, "/Lingma") || file.Name == "Lingma" {
return file.Name
}
}
return ""
}
func platformBinarySuffix() string {
if runtime.GOOS == "linux" && runtime.GOARCH == "amd64" {
return "x86_64_linux/Lingma"
}
if runtime.GOOS == "linux" && runtime.GOARCH == "arm64" {
return "arm64_linux/Lingma"
}
if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
return "arm64_darwin/Lingma"
}
if runtime.GOOS == "darwin" {
return "x86_64_darwin/Lingma"
}
if runtime.GOOS == "windows" && runtime.GOARCH == "arm64" {
return "arm64_windows/Lingma"
}
if runtime.GOOS == "windows" {
return "x86_64_windows/Lingma"
}
return "/Lingma"
}
func inferReleaseRoot(memberPath string) string {
parts := strings.Split(memberPath, "/")
platforms := []string{"x86_64_linux", "arm64_linux", "x86_64_darwin", "arm64_darwin", "x86_64_windows", "arm64_windows"}
for _, platform := range platforms {
for i, part := range parts {
if part == platform && i > 0 {
return strings.Join(parts[:i], "/")
}
}
}
if len(parts) > 1 {
return parts[0]
}
return ""
}
func writeReleaseFiles(releaseDir string, releaseRoot string, files []zipEntry) error {
prefix := ""
if releaseRoot != "" {
prefix = releaseRoot + "/"
}
for _, entry := range files {
rel := entry.Name
if prefix != "" {
rel = strings.TrimPrefix(rel, prefix)
}
if rel == "" {
continue
}
dest := filepath.Join(releaseDir, filepath.FromSlash(rel))
if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
return err
}
mode := entry.Mode
if mode == 0 {
mode = 0o644
}
if strings.HasSuffix(rel, "/Lingma") || filepath.Base(rel) == "Lingma" {
mode = 0o755
}
if err := os.WriteFile(dest, entry.Data, mode); err != nil {
return err
}
}
return nil
}
func releaseDirForOutput(outputDir string, releaseRoot string) string {
name := strings.TrimSpace(releaseRoot)
if name == "" {
return outputDir
}
return filepath.Join(outputDir, filepath.FromSlash(name))
}
func hasRequiredAssets(releaseDir string) bool {
info, err := os.Stat(filepath.Join(releaseDir, "extension", "main.js"))
return err == nil && !info.IsDir()
}
func readMarker(path string) marker {
body, err := os.ReadFile(path)
if err != nil {
return marker{}
}
var mk marker
if err := json.Unmarshal(body, &mk); err != nil {
return marker{}
}
return mk
}
func writeMarker(path string, mk marker) error {
body, err := json.MarshalIndent(mk, "", " ")
if err != nil {
return err
}
return os.WriteFile(path, body, 0o644)
}
func fileExists(path string) bool {
info, err := os.Stat(path)
return err == nil && !info.IsDir()
}
func versionOrUnknown(version string) string {
if strings.TrimSpace(version) == "" {
return "unknown version"
}
return version
}

187
internal/httpapi/server.go
View File

@@ -116,14 +116,17 @@ func NewServer(addr string, svc *service.Service) *Server {
mux.HandleFunc("/api/tags", s.handleOllamaTags)
mux.HandleFunc("/v1/props", s.handleModelProps)
mux.HandleFunc("/props", s.handleModelProps)
mux.HandleFunc("/v1/runtime/status", s.handleRuntimeStatus)
mux.HandleFunc("/runtime/status", s.handleRuntimeStatus)
mux.HandleFunc("/version", s.handleVersion)
mux.HandleFunc("/v1/messages/count_tokens", s.handleAnthropicCountTokens)
mux.HandleFunc("/v1/messages", s.handleAnthropicMessages)
mux.HandleFunc("/v1/chat/completions", s.handleOpenAIChatCompletions)
mux.HandleFunc("/api/v1/chat/completions", s.handleOpenAIChatCompletions)
s.http = &http.Server{
Addr: addr,
Handler: s.withRecorder(withCORS(mux)),
Handler: s.withRecorder(withCORS(s.withAuth(mux))),
ReadHeaderTimeout: 10 * time.Second,
}
return s
@@ -178,11 +181,32 @@ func (s *Server) handleRoot(w http.ResponseWriter, r *http.Request) {
}
writeJSON(w, http.StatusOK, map[string]any{
"ok": true,
"service": "lingma-ipc-proxy",
"service": "lingma-proxy",
"state": s.svc.State(),
})
}
func (s *Server) handleRuntimeStatus(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodOptions {
w.WriteHeader(http.StatusNoContent)
return
}
if r.Method == http.MethodHead {
w.WriteHeader(http.StatusOK)
return
}
if r.Method != http.MethodGet {
writeOpenAIError(w, http.StatusMethodNotAllowed, "invalid_request_error", "method not allowed")
return
}
state := s.svc.State()
writeJSON(w, http.StatusOK, map[string]any{
"ok": state.Connected,
"service": "lingma-proxy",
"state": state,
})
}
func (s *Server) handleDebugRequests(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodOptions {
w.WriteHeader(http.StatusNoContent)
@@ -214,7 +238,7 @@ func (s *Server) handleDebugRequests(w http.ResponseWriter, r *http.Request) {
records := s.debugRecords(limit)
writeJSON(w, http.StatusOK, map[string]any{
"ok": true,
"service": "lingma-ipc-proxy",
"service": "lingma-proxy",
"count": len(records),
"requests": records,
"state": s.svc.State(),
@@ -265,7 +289,7 @@ func (s *Server) handleCapabilities(w http.ResponseWriter, r *http.Request) {
}
writeJSON(w, http.StatusOK, map[string]any{
"service": "lingma-ipc-proxy",
"service": "lingma-proxy",
"protocols": []string{
"openai.chat_completions",
"anthropic.messages",
@@ -441,8 +465,29 @@ func (s *Server) handleVersion(w http.ResponseWriter, r *http.Request) {
return
}
writeJSON(w, http.StatusOK, map[string]any{
"version": "lingma-ipc-proxy",
"service": "lingma-ipc-proxy",
"version": "lingma-proxy",
"service": "lingma-proxy",
})
}
func (s *Server) handleAnthropicCountTokens(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodOptions {
w.WriteHeader(http.StatusNoContent)
return
}
if r.Method != http.MethodPost {
writeAnthropicError(w, http.StatusMethodNotAllowed, "invalid_request_error", "method not allowed")
return
}
var req anthropicRequest
if err := decodeJSON(r, &req); err != nil {
writeAnthropicError(w, http.StatusBadRequest, "invalid_request_error", err.Error())
return
}
writeJSON(w, http.StatusOK, map[string]any{
"input_tokens": estimateAnthropicInputTokens(req),
})
}
@@ -1186,7 +1231,7 @@ func (s *Server) handleOpenAIStream(w http.ResponseWriter, r *http.Request, req
}
func shouldAggregateToolStream(req service.ChatRequest) bool {
return len(req.Tools) > 0 && truthyEnv("LINGMA_AGGREGATE_TOOL_STREAM")
return len(req.Tools) > 0
}
type toolStreamFilter struct {
@@ -1292,6 +1337,9 @@ func anthropicHostedWebSearchCall(req anthropicRequest) (toolemulation.ToolCall,
if !hasAnthropicHostedWebSearchTool(req.Tools) {
return toolemulation.ToolCall{}, false
}
if hasAnthropicToolResult(req.Messages) {
return toolemulation.ToolCall{}, false
}
if !anthropicHostedWebSearchRequested(req.Tools, req.ToolChoice) {
return toolemulation.ToolCall{}, false
}
@@ -1307,6 +1355,46 @@ func anthropicHostedWebSearchCall(req anthropicRequest) (toolemulation.ToolCall,
}, true
}
func hasAnthropicToolResult(messages []rawMessage) bool {
for _, message := range messages {
items, ok := message.Content.([]any)
if !ok {
continue
}
for _, item := range items {
m, ok := item.(map[string]any)
if ok && stringFromAny(m["type"]) == "tool_result" {
return true
}
}
}
return false
}
func estimateAnthropicInputTokens(req anthropicRequest) int {
payload := map[string]any{
"model": req.Model,
"system": req.System,
"messages": req.Messages,
"tools": req.Tools,
"tool_choice": req.ToolChoice,
"thinking": req.Thinking,
}
raw, err := json.Marshal(payload)
if err != nil {
return 1
}
runes := len([]rune(string(raw)))
if runes == 0 {
return 1
}
tokens := (runes + 2) / 3
if tokens < 1 {
return 1
}
return tokens
}
func hasAnthropicHostedWebSearchTool(raw any) bool {
items, ok := raw.([]any)
if !ok {
@@ -1385,20 +1473,18 @@ func normalizeAnthropicRequest(req anthropicRequest) (service.ChatRequest, error
case "user":
text, toolResults := extractAnthropicUserContent(message.Content)
images := extractAnthropicImages(message.Content)
for _, tr := range toolResults {
prompt := toolemulation.ActionOutputPrompt(tr.ToolUseID, tr.Content)
if prompt != "" {
messages = append(messages, service.ChatMessage{Role: "user", Text: prompt})
}
}
if text != "" || len(images) > 0 {
messages = append(messages, service.ChatMessage{Role: role, Text: text, Images: images})
}
for _, tr := range toolResults {
if strings.TrimSpace(tr.Content) != "" {
messages = append(messages, service.ChatMessage{Role: "tool", Text: tr.Content, ToolCallID: tr.ToolUseID})
}
}
case "assistant":
text, calls := extractAnthropicAssistantContent(message.Content)
projected := toolemulation.AssistantToolCallsToText(text, calls)
if projected != "" {
messages = append(messages, service.ChatMessage{Role: role, Text: projected})
if text != "" || len(calls) > 0 {
messages = append(messages, service.ChatMessage{Role: role, Text: text, ToolCalls: calls})
}
}
}
@@ -1445,19 +1531,15 @@ func normalizeOpenAIRequest(req openAIChatRequest) (service.ChatRequest, error)
case "assistant":
text := strings.TrimSpace(extractText(message.Content))
calls := extractOpenAIToolCalls(message.ToolCalls)
projected := toolemulation.AssistantToolCallsToText(text, calls)
if projected != "" {
messages = append(messages, service.ChatMessage{Role: role, Text: projected})
if text != "" || len(calls) > 0 {
messages = append(messages, service.ChatMessage{Role: role, Text: text, ToolCalls: calls})
}
case "tool":
output := strings.TrimSpace(extractText(message.Content))
if output == "" || message.ToolCallID == "" {
continue
}
prompt := toolemulation.ActionOutputPrompt(message.ToolCallID, output)
if prompt != "" {
messages = append(messages, service.ChatMessage{Role: "user", Text: prompt})
}
messages = append(messages, service.ChatMessage{Role: "tool", Text: output, ToolCallID: message.ToolCallID})
}
}
if len(messages) == 0 {
@@ -1604,6 +1686,65 @@ func writeOpenAIError(w http.ResponseWriter, status int, kind string, message st
})
}
func isPublicPath(path string) bool {
switch path {
case "/", "/health", "/runtime/status", "/v1/runtime/status":
return true
default:
return false
}
}
func isAnthropicPath(path string) bool {
switch path {
case "/v1/messages", "/v1/messages/count_tokens":
return true
default:
return false
}
}
func extractAPIKey(r *http.Request) string {
if value := strings.TrimSpace(r.Header.Get("x-api-key")); value != "" {
return value
}
auth := strings.TrimSpace(r.Header.Get("Authorization"))
if auth == "" {
return ""
}
parts := strings.SplitN(auth, " ", 2)
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") {
return ""
}
return strings.TrimSpace(parts[1])
}
func (s *Server) withAuth(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if isPublicPath(r.URL.Path) {
next.ServeHTTP(w, r)
return
}
keys := s.svc.APIKeys()
if len(keys) == 0 {
next.ServeHTTP(w, r)
return
}
provided := extractAPIKey(r)
for _, key := range keys {
if provided == key {
next.ServeHTTP(w, r)
return
}
}
if isAnthropicPath(r.URL.Path) {
writeAnthropicError(w, http.StatusUnauthorized, "authentication_error", "invalid or missing API key")
return
}
writeOpenAIError(w, http.StatusUnauthorized, "authentication_error", "invalid or missing API key")
})
}
func streamingHeaders(w http.ResponseWriter) {
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("Cache-Control", "no-cache")

135
internal/httpapi/server_test.go
View File

@@ -81,6 +81,83 @@ func TestCapabilitiesAdvertiseAgentCompatibility(t *testing.T) {
}
}
func TestAuthAllowsPublicHealthWithoutAPIKey(t *testing.T) {
server := NewServer("", service.New(service.Config{
Model: "Qwen3-Coder",
Timeout: time.Second,
APIKeys: []string{"key-1", "key-2"},
}))
req := httptest.NewRequest(http.MethodGet, "/health", nil)
rec := httptest.NewRecorder()
server.http.Handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status = %d body = %s", rec.Code, rec.Body.String())
}
}
func TestAuthRejectsProtectedEndpointWithoutAPIKey(t *testing.T) {
server := NewServer("", service.New(service.Config{
Model: "Qwen3-Coder",
Timeout: time.Second,
APIKeys: []string{"key-1", "key-2"},
}))
req := httptest.NewRequest(http.MethodGet, "/capabilities", nil)
rec := httptest.NewRecorder()
server.http.Handler.ServeHTTP(rec, req)
if rec.Code != http.StatusUnauthorized {
t.Fatalf("status = %d body = %s", rec.Code, rec.Body.String())
}
if !strings.Contains(rec.Body.String(), "authentication_error") {
t.Fatalf("body = %s", rec.Body.String())
}
}
func TestAuthAcceptsBearerAndXAPIKey(t *testing.T) {
server := NewServer("", service.New(service.Config{
Model: "Qwen3-Coder",
Timeout: time.Second,
APIKeys: []string{"key-1", "key-2"},
}))
bearerReq := httptest.NewRequest(http.MethodGet, "/capabilities", nil)
bearerReq.Header.Set("Authorization", "Bearer key-2")
bearerRec := httptest.NewRecorder()
server.http.Handler.ServeHTTP(bearerRec, bearerReq)
if bearerRec.Code != http.StatusOK {
t.Fatalf("bearer status = %d body = %s", bearerRec.Code, bearerRec.Body.String())
}
xReq := httptest.NewRequest(http.MethodGet, "/capabilities", nil)
xReq.Header.Set("x-api-key", "key-1")
xRec := httptest.NewRecorder()
server.http.Handler.ServeHTTP(xRec, xReq)
if xRec.Code != http.StatusOK {
t.Fatalf("x-api-key status = %d body = %s", xRec.Code, xRec.Body.String())
}
}
func TestAnthropicAuthErrorShape(t *testing.T) {
server := NewServer("", service.New(service.Config{
Model: "Qwen3-Coder",
Timeout: time.Second,
APIKeys: []string{"key-1"},
}))
req := httptest.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader(`{"model":"kmodel","messages":[{"role":"user","content":"hello"}],"max_tokens":16}`))
req.Header.Set("Content-Type", "application/json")
rec := httptest.NewRecorder()
server.http.Handler.ServeHTTP(rec, req)
if rec.Code != http.StatusUnauthorized {
t.Fatalf("status = %d body = %s", rec.Code, rec.Body.String())
}
if !strings.Contains(rec.Body.String(), `"type":"error"`) {
t.Fatalf("body = %s", rec.Body.String())
}
}
func TestNormalizeOpenAIRequestRejectsMissingUserAndAssistantMessages(t *testing.T) {
req := openAIChatRequest{
Model: "test-model",
@@ -218,6 +295,64 @@ func TestAnthropicHostedWebSearchCallIgnoresRegularClientWebSearch(t *testing.T)
}
}
func TestAnthropicHostedWebSearchCallIgnoresToolResultFollowup(t *testing.T) {
req := anthropicRequest{
Tools: []any{
map[string]any{
"name": "web_search",
"type": "web_search_20250305",
},
},
ToolChoice: map[string]any{
"type": "tool",
"name": "web_search",
},
Messages: []rawMessage{{
Role: "user",
Content: []any{
map[string]any{
"type": "tool_result",
"tool_use_id": "toolu_123",
"content": "result",
},
},
}},
}
if _, ok := anthropicHostedWebSearchCall(req); ok {
t.Fatal("hosted web_search should not short-circuit after a tool_result")
}
}
func TestAnthropicCountTokensEndpoint(t *testing.T) {
server := NewServer("", service.New(service.Config{
Model: "Qwen3-Coder",
Timeout: time.Second,
}))
req := httptest.NewRequest(http.MethodPost, "/v1/messages/count_tokens", strings.NewReader(`{
"model":"kmodel",
"max_tokens":128,
"system":"You are concise.",
"messages":[{"role":"user","content":"hello"}],
"tools":[{"name":"read_file","input_schema":{"type":"object","properties":{"file_path":{"type":"string"}},"required":["file_path"]}}]
}`))
req.Header.Set("Content-Type", "application/json")
rec := httptest.NewRecorder()
server.http.Handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status = %d body = %s", rec.Code, rec.Body.String())
}
var body map[string]any
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatal(err)
}
if body["input_tokens"].(float64) <= 0 {
t.Fatalf("input_tokens = %#v", body["input_tokens"])
}
}
func TestDiscoveryCompatibilityEndpoints(t *testing.T) {
server := NewServer("", service.New(service.Config{
Model: "Qwen3-Coder",

387
internal/remote/client.go
View File

@@ -12,10 +12,13 @@ import (
"net/url"
"os"
"path/filepath"
"regexp"
"sort"
"strconv"
"strings"
"time"
"lingma-ipc-proxy/internal/toolemulation"
)
const (
@@ -25,6 +28,8 @@ const (
modelListPath = "/algo/api/v2/model/list"
)
var remoteBaseURLPattern = regexp.MustCompile(`https?://[^\s"'<>),\]}]+`)
type Config struct {
BaseURL string
AuthFile string
@@ -52,8 +57,27 @@ type Model struct {
type ChatRequest struct {
Model string
Prompt string
Messages []Message
Images []Image
Stream bool
Temperature *float64
Tools []toolemulation.ToolDef
ToolChoice toolemulation.ToolChoice
}
type Image struct {
MediaType string
Data string
URL string
}
type Message struct {
Role string
Content string
Images []Image
Name string
ToolCallID string
ToolCalls []toolemulation.ToolCall
}
type ChatResult struct {
@@ -62,6 +86,7 @@ type ChatResult struct {
OutputTokens int
RequestID string
CredentialSrc string
ToolCalls []toolemulation.ToolCall
}
type StreamEvent struct {
@@ -75,9 +100,6 @@ func New(cfg Config) *Client {
if cfg.CosyVersion == "" {
cfg.CosyVersion = "2.11.2"
}
if cfg.Timeout <= 0 {
cfg.Timeout = 300 * time.Second
}
cfg.BaseURL = strings.TrimRight(cfg.BaseURL, "/")
return &Client{cfg: cfg, client: &http.Client{Timeout: cfg.Timeout}}
}
@@ -135,7 +157,7 @@ func (c *Client) ListModels(ctx context.Context) ([]Model, error) {
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
if resp.StatusCode >= 400 {
return nil, fmt.Errorf("remote model list status %d: %s", resp.StatusCode, truncate(string(body), 500))
return nil, c.modelListStatusError(resp.StatusCode, string(body))
}
var payload struct {
Chat []Model `json:"chat"`
@@ -147,6 +169,14 @@ func (c *Client) ListModels(ctx context.Context) ([]Model, error) {
return append(payload.Chat, payload.Inline...), nil
}
func (c *Client) modelListStatusError(statusCode int, body string) error {
message := fmt.Sprintf("remote model list status %d from %s: %s", statusCode, c.cfg.BaseURL, truncate(body, 500))
if statusCode == http.StatusNotFound || strings.Contains(body, "NoSuchKey") {
message += "。这通常表示远端 API 域名自动探测命中了错误地址，请到设置页手动填写 Lingma 官方或企业专属远端 API 域名；官方默认域名为 https://lingma.alibabacloud.com。"
}
return fmt.Errorf("%s", message)
}
func (c *Client) Chat(ctx context.Context, request ChatRequest, onDelta func(string)) (*ChatResult, error) {
cred, err := LoadCredential(c.cfg.AuthFile)
if err != nil {
@@ -178,10 +208,14 @@ func (c *Client) Chat(ctx context.Context, request ChatRequest, onDelta func(str
return nil, fmt.Errorf("remote chat status %d: %s", resp.StatusCode, truncate(string(respBody), 1000))
}
var builder strings.Builder
toolCallBuffer := newRemoteToolCallBuffer()
if err := scanSSE(resp.Body, func(event sseEvent) error {
if event.Done {
return nil
}
if len(event.ToolCalls) > 0 {
toolCallBuffer.Add(event.ToolCalls)
}
if event.Content == "" {
return nil
}
@@ -200,6 +234,7 @@ func (c *Client) Chat(ctx context.Context, request ChatRequest, onDelta func(str
OutputTokens: estimateTokens(text),
RequestID: requestID,
CredentialSrc: cred.Source,
ToolCalls: toolCallBuffer.Calls(),
}, nil
}
@@ -212,12 +247,13 @@ func (c *Client) buildBody(requestID string, request ChatRequest) (string, error
if strings.EqualFold(model, "auto") {
model = ""
}
imageURLs := projectImages(request.Images)
payload := map[string]any{
"request_id": requestID,
"request_set_id": "",
"chat_record_id": requestID,
"stream": true,
"image_urls": nil,
"image_urls": nullableSlice(imageURLs),
"is_reply": false,
"is_retry": false,
"session_id": "",
@@ -234,26 +270,14 @@ func (c *Client) buildBody(requestID string, request ChatRequest) (string, error
"display_name": "",
"model": model,
"format": "",
"is_vl": false,
"is_vl": len(imageURLs) > 0,
"is_reasoning": false,
"api_key": "",
"url": "",
"source": "",
"enable": false,
},
"messages": []map[string]any{{
"role": "user",
"content": request.Prompt,
"response_meta": map[string]any{
"id": "",
"usage": map[string]int{
"prompt_tokens": 0,
"completion_tokens": 0,
"total_tokens": 0,
},
},
"reasoning_content_signature": "",
}},
"messages": projectMessages(request),
"business": map[string]any{
"product": "jb_plugin",
"version": c.cfg.CosyVersion,
@@ -264,10 +288,193 @@ func (c *Client) buildBody(requestID string, request ChatRequest) (string, error
"name": "memory_intent_recognition_" + requestID,
},
}
if tools := projectTools(request.Tools); len(tools) > 0 {
payload["tools"] = tools
}
if choice := projectToolChoice(request.ToolChoice); choice != nil {
payload["tool_choice"] = choice
}
body, err := json.Marshal(payload)
return string(body), err
}
func nullableSlice[T any](items []T) any {
if len(items) == 0 {
return nil
}
return items
}
func projectImages(images []Image) []string {
if len(images) == 0 {
return nil
}
out := make([]string, 0, len(images))
for _, img := range images {
item := projectImage(img)
if item != "" {
out = append(out, item)
}
}
return out
}
func projectImage(img Image) string {
if strings.TrimSpace(img.Data) == "" && strings.TrimSpace(img.URL) == "" {
return ""
}
mediaType := strings.TrimSpace(img.MediaType)
if mediaType == "" {
mediaType = "image/jpeg"
}
if strings.TrimSpace(img.Data) != "" {
return "data:" + mediaType + ";base64," + strings.TrimSpace(img.Data)
}
return strings.TrimSpace(img.URL)
}
func projectMessages(request ChatRequest) []map[string]any {
source := request.Messages
if len(source) == 0 {
source = []Message{{Role: "user", Content: request.Prompt}}
}
out := make([]map[string]any, 0, len(source))
for _, message := range source {
role := strings.TrimSpace(message.Role)
if role == "" {
continue
}
item := map[string]any{
"role": role,
"content": projectMessageContent(message),
"response_meta": map[string]any{
"id": "",
"usage": map[string]int{
"prompt_tokens": 0,
"completion_tokens": 0,
"total_tokens": 0,
},
},
"reasoning_content_signature": "",
}
if message.Name != "" {
item["name"] = message.Name
}
if message.ToolCallID != "" {
item["tool_call_id"] = message.ToolCallID
}
if calls := projectMessageToolCalls(message.ToolCalls); len(calls) > 0 {
item["tool_calls"] = calls
}
out = append(out, item)
}
if len(out) == 0 {
return []map[string]any{{"role": "user", "content": request.Prompt}}
}
return out
}
func projectMessageContent(message Message) any {
if len(message.Images) == 0 {
return message.Content
}
content := make([]map[string]any, 0, len(message.Images)+1)
if strings.TrimSpace(message.Content) != "" {
content = append(content, map[string]any{
"type": "text",
"text": message.Content,
})
}
for _, img := range message.Images {
imageURL := projectImage(img)
if imageURL == "" {
continue
}
content = append(content, map[string]any{
"type": "image_url",
"image_url": map[string]any{
"url": imageURL,
},
})
}
if len(content) == 0 {
return message.Content
}
return content
}
func projectMessageToolCalls(calls []toolemulation.ToolCall) []map[string]any {
if len(calls) == 0 {
return nil
}
out := make([]map[string]any, 0, len(calls))
for i, call := range calls {
name := strings.TrimSpace(call.Name)
if name == "" {
continue
}
args, _ := json.Marshal(call.Arguments)
out = append(out, map[string]any{
"index": i,
"id": strings.TrimSpace(call.ID),
"type": "function",
"function": map[string]any{
"name": name,
"arguments": string(args),
},
})
}
return out
}
func projectTools(tools []toolemulation.ToolDef) []map[string]any {
if len(tools) == 0 {
return nil
}
out := make([]map[string]any, 0, len(tools))
for _, tool := range tools {
name := strings.TrimSpace(tool.Name)
if name == "" {
continue
}
params := any(tool.InputSchema)
if len(tool.InputSchema) == 0 {
params = map[string]any{"type": "object", "properties": map[string]any{}}
}
out = append(out, map[string]any{
"type": "function",
"function": map[string]any{
"name": name,
"description": strings.TrimSpace(tool.Description),
"parameters": params,
},
})
}
return out
}
func projectToolChoice(choice toolemulation.ToolChoice) any {
switch choice.Mode {
case "none":
return "none"
case "any":
return "required"
case "tool":
name := strings.TrimSpace(choice.Name)
if name == "" {
return nil
}
return map[string]any{
"type": "function",
"function": map[string]any{
"name": name,
},
}
default:
return nil
}
}
func (c *Client) headers(cred Credential, path string, body string) (map[string]string, error) {
if err := validateCredential(cred); err != nil {
return nil, err
@@ -308,7 +515,7 @@ func (c *Client) headers(cred Credential, path string, body string) (map[string]
"Cosy-Machinetype": "",
"Cosy-Version": c.cfg.CosyVersion,
"Login-Version": "v2",
"User-Agent": "lingma-ipc-proxy/remote",
"User-Agent": "lingma-proxy/remote",
"Accept": "text/event-stream",
"Cache-Control": "no-cache",
}, nil
@@ -327,15 +534,35 @@ type innerSSE struct {
Choices []struct {
Delta struct {
Content string `json:"content"`
ToolCalls []remoteToolCallDelta `json:"tool_calls"`
} `json:"delta"`
} `json:"choices"`
}
type sseEvent struct {
Content string
ToolCalls []remoteToolCallFragment
Done bool
}
type remoteToolCallFragment struct {
Index int
ID string
Type string
Name string
ArgumentsFragment string
}
type remoteToolCallDelta struct {
Index int `json:"index"`
ID string `json:"id,omitempty"`
Type string `json:"type,omitempty"`
Function struct {
Name string `json:"name,omitempty"`
Arguments string `json:"arguments,omitempty"`
} `json:"function,omitempty"`
}
func scanSSE(reader io.Reader, onEvent func(sseEvent) error) error {
scanner := bufio.NewScanner(reader)
scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
@@ -381,10 +608,94 @@ func parseSSEPayload(payload string) (sseEvent, bool, error) {
return sseEvent{}, false, err
}
var builder strings.Builder
var toolCalls []remoteToolCallFragment
for _, choice := range inner.Choices {
builder.WriteString(choice.Delta.Content)
for _, tc := range choice.Delta.ToolCalls {
toolCalls = append(toolCalls, remoteToolCallFragment{
Index: tc.Index,
ID: strings.TrimSpace(tc.ID),
Type: strings.TrimSpace(tc.Type),
Name: strings.TrimSpace(tc.Function.Name),
ArgumentsFragment: tc.Function.Arguments,
})
}
return sseEvent{Content: builder.String()}, true, nil
}
return sseEvent{Content: builder.String(), ToolCalls: toolCalls}, true, nil
}
type remoteToolCallBuffer struct {
order []int
states map[int]*remoteToolCallState
}
type remoteToolCallState struct {
id string
callType string
name string
arguments strings.Builder
}
func newRemoteToolCallBuffer() *remoteToolCallBuffer {
return &remoteToolCallBuffer{states: map[int]*remoteToolCallState{}}
}
func (b *remoteToolCallBuffer) Add(fragments []remoteToolCallFragment) {
if b == nil {
return
}
for _, fragment := range fragments {
state := b.states[fragment.Index]
if state == nil {
state = &remoteToolCallState{}
b.states[fragment.Index] = state
b.order = append(b.order, fragment.Index)
}
if fragment.ID != "" {
state.id = fragment.ID
}
if fragment.Type != "" {
state.callType = fragment.Type
}
if fragment.Name != "" {
state.name = fragment.Name
}
if fragment.ArgumentsFragment != "" {
state.arguments.WriteString(fragment.ArgumentsFragment)
}
}
}
func (b *remoteToolCallBuffer) Calls() []toolemulation.ToolCall {
if b == nil || len(b.order) == 0 {
return nil
}
out := make([]toolemulation.ToolCall, 0, len(b.order))
for _, index := range b.order {
state := b.states[index]
if state == nil || strings.TrimSpace(state.name) == "" {
continue
}
args := strings.TrimSpace(state.arguments.String())
call := toolemulation.ToolCall{
ID: strings.TrimSpace(state.id),
Name: strings.TrimSpace(state.name),
Arguments: map[string]any{},
}
if args != "" {
var parsed map[string]any
if err := json.Unmarshal([]byte(args), &parsed); err == nil {
call.Arguments = parsed
} else {
call.Arguments = map[string]any{"raw_arguments": args}
}
}
if call.ID == "" {
call.ID = fmt.Sprintf("toolu_%d_%d", time.Now().UnixNano(), index)
}
out = append(out, call)
}
return out
}
func candidateConfigFiles() []string {
@@ -396,6 +707,7 @@ func candidateConfigFiles() []string {
filepath.Join(home, ".lingma", "extension", "server", "config.json"),
filepath.Join(home, ".lingma", "extension", "local", "config.json"),
filepath.Join(home, ".lingma", "bin", "config.json"),
filepath.Join(home, ".config", "lingma-proxy", "config.json"),
filepath.Join(home, ".config", "lingma-ipc-proxy", "config.json"),
filepath.Join(home, ".lingma", "logs", "lingma.log"),
filepath.Join(home, ".lingma", "logs", "lingma-extension.log"),
@@ -537,12 +849,16 @@ func uniqueStrings(values []string) []string {
}
func extractBaseURLFromText(text string) string {
matches := remoteBaseURLPattern.FindAllString(text, -1)
for i := len(matches) - 1; i >= 0; i-- {
if value := normalizeRemoteBaseURLHint(matches[i]); value != "" {
return value
}
}
for _, marker := range []string{
"endpoint config:",
"Using service url:",
"Download asset from:",
"https://ai-lingma",
"https://lingma",
} {
if value := extractBaseURLAfterMarker(text, marker); value != "" {
return value
@@ -576,17 +892,40 @@ func normalizeRemoteBaseURLHint(raw string) string {
if raw == "" {
return ""
}
if strings.HasPrefix(raw, "ttps://") {
raw = "h" + raw
}
parsed, err := url.Parse(raw)
if err != nil || parsed.Scheme == "" || parsed.Host == "" {
return ""
}
if parsed.Scheme != "http" && parsed.Scheme != "https" {
return ""
}
host := strings.ToLower(parsed.Host)
if !strings.Contains(host, "lingma") && !strings.Contains(host, "rdc.aliyuncs.com") {
if !isRemoteAPIHost(host) {
return ""
}
return parsed.Scheme + "://" + parsed.Host
}
func isRemoteAPIHost(host string) bool {
if host == "" {
return false
}
if strings.Contains(host, ".oss-") || strings.Contains(host, "oss-rg-") || strings.Contains(host, ".oss.") {
return false
}
switch host {
case "lingma.alibabacloud.com", "lingma-api.tongyi.aliyun.com":
return true
}
if strings.HasSuffix(host, ".rdc.aliyuncs.com") {
return true
}
return false
}
func estimateTokens(text string) int {
text = strings.TrimSpace(text)
if text == "" {

299
internal/remote/client_test.go
View File

@@ -1,19 +1,308 @@
package remote
import "testing"
import (
"encoding/json"
"os"
"path/filepath"
"strings"
"testing"
"time"
"lingma-ipc-proxy/internal/toolemulation"
)
func TestNewKeepsZeroTimeoutUnlimited(t *testing.T) {
client := New(Config{Timeout: 0})
if client.client.Timeout != 0 {
t.Fatalf("timeout = %v, want 0", client.client.Timeout)
}
}
func TestNewKeepsPositiveTimeout(t *testing.T) {
client := New(Config{Timeout: 7 * time.Second})
if client.client.Timeout != 7*time.Second {
t.Fatalf("timeout = %v, want 7s", client.client.Timeout)
}
}
func TestExtractBaseURLFromEndpointLog(t *testing.T) {
got := extractBaseURLFromText(`2026-04-10 INFO Update endpoint success. endpoint config: https://ai-lingma-cmb01-cn-beijing.rdc.aliyuncs.com`)
want := "https://ai-lingma-cmb01-cn-beijing.rdc.aliyuncs.com"
got := extractBaseURLFromText(`2026-04-10 INFO Update endpoint success. endpoint config: https://ai-lingma-example-cn-beijing.rdc.aliyuncs.com`)
want := "https://ai-lingma-example-cn-beijing.rdc.aliyuncs.com"
if got != want {
t.Fatalf("got %q, want %q", got, want)
}
}
func TestExtractBaseURLFromMarketplaceLog(t *testing.T) {
got := extractBaseURLFromText(`2026-04-30 [info] [Marketplace] Using service url: https://ai-lingma-cmb01-cn-beijing.rdc.aliyuncs.com/marketplace/_apis/public/gallery`)
want := "https://ai-lingma-cmb01-cn-beijing.rdc.aliyuncs.com"
got := extractBaseURLFromText(`2026-04-30 [info] [Marketplace] Using service url: https://ai-lingma-example-cn-beijing.rdc.aliyuncs.com/marketplace/_apis/public/gallery`)
want := "https://ai-lingma-example-cn-beijing.rdc.aliyuncs.com"
if got != want {
t.Fatalf("got %q, want %q", got, want)
}
}
func TestExtractBaseURLFromRawWindowsLogURL(t *testing.T) {
got := extractBaseURLFromText(`2026-05-06T12:00:00 endpoint=https://ai-lingma-example-cn-beijing.rdc.aliyuncs.com/algo/api/v2/model/list`)
want := "https://ai-lingma-example-cn-beijing.rdc.aliyuncs.com"
if got != want {
t.Fatalf("got %q, want %q", got, want)
}
}
func TestExtractBaseURLIgnoresLingmaOSSAssetHost(t *testing.T) {
got := extractBaseURLFromText(`2026-05-06 endpoint config: https://ai-lingma-example-cn-beijing.rdc.aliyuncs.com
2026-05-06 Download asset from: https://lingma-ide.oss-rg-china-mainland.aliyuncs.com/lingma-extension/download?name=plugin.zip`)
want := "https://ai-lingma-example-cn-beijing.rdc.aliyuncs.com"
if got != want {
t.Fatalf("got %q, want %q", got, want)
}
}
func TestNormalizeBaseURLRepairsMissingLeadingH(t *testing.T) {
got := normalizeRemoteBaseURLHint(`ttps://ai-lingma-example-cn-beijing.rdc.aliyuncs.com`)
want := "https://ai-lingma-example-cn-beijing.rdc.aliyuncs.com"
if got != want {
t.Fatalf("got %q, want %q", got, want)
}
}
func TestNormalizeBaseURLRejectsLingmaOSSAssetHost(t *testing.T) {
if got := normalizeRemoteBaseURLHint(`https://lingma-ide.oss-rg-china-mainland.aliyuncs.com/lingma-extension/download`); got != "" {
t.Fatalf("got %q, want empty", got)
}
}
func TestNormalizeBaseURLRejectsUnsupportedScheme(t *testing.T) {
if got := normalizeRemoteBaseURLHint(`ftp://ai-lingma-example-cn-beijing.rdc.aliyuncs.com`); got != "" {
t.Fatalf("got %q, want empty", got)
}
}
func TestModelListStatusErrorSuggestsManualRemoteBaseURLOn404(t *testing.T) {
client := New(Config{BaseURL: "https://lingma-ide.oss-rg-china-mainland.aliyuncs.com"})
err := client.modelListStatusError(404, `<Error><Code>NoSuchKey</Code></Error>`)
if err == nil {
t.Fatal("expected error")
}
text := err.Error()
for _, want := range []string{
"https://lingma-ide.oss-rg-china-mainland.aliyuncs.com",
"远端 API 域名自动探测命中了错误地址",
"https://lingma.alibabacloud.com",
} {
if !strings.Contains(text, want) {
t.Fatalf("error %q missing %q", text, want)
}
}
}
func TestBuildBodyProjectsNativeTools(t *testing.T) {
client := New(Config{})
body, err := client.buildBody("req-1", ChatRequest{
Model: "kmodel",
Prompt: "read file",
Tools: []toolemulation.ToolDef{{
Name: "read_file",
Description: "Read a local file",
InputSchema: map[string]any{
"type": "object",
"properties": map[string]any{
"file_path": map[string]any{"type": "string"},
},
"required": []any{"file_path"},
},
}},
ToolChoice: toolemulation.ToolChoice{Mode: "tool", Name: "read_file"},
})
if err != nil {
t.Fatal(err)
}
var payload map[string]any
if err := json.Unmarshal([]byte(body), &payload); err != nil {
t.Fatal(err)
}
tools, ok := payload["tools"].([]any)
if !ok || len(tools) != 1 {
t.Fatalf("tools = %#v", payload["tools"])
}
tool := tools[0].(map[string]any)
fn := tool["function"].(map[string]any)
if tool["type"] != "function" || fn["name"] != "read_file" {
t.Fatalf("unexpected tool projection: %#v", tool)
}
choice := payload["tool_choice"].(map[string]any)
choiceFn := choice["function"].(map[string]any)
if choice["type"] != "function" || choiceFn["name"] != "read_file" {
t.Fatalf("unexpected tool choice: %#v", payload["tool_choice"])
}
}
func TestBuildBodyPreservesStructuredToolMessages(t *testing.T) {
client := New(Config{})
body, err := client.buildBody("req-1", ChatRequest{
Model: "kmodel",
Prompt: "fallback prompt",
Messages: []Message{
{Role: "user", Content: "查看项目"},
{Role: "assistant", ToolCalls: []toolemulation.ToolCall{{
ID: "call_1",
Name: "Bash",
Arguments: map[string]any{"command": "pwd && ls -la"},
}}},
{Role: "tool", ToolCallID: "call_1", Content: "total 10"},
},
})
if err != nil {
t.Fatal(err)
}
var payload map[string]any
if err := json.Unmarshal([]byte(body), &payload); err != nil {
t.Fatal(err)
}
messages := payload["messages"].([]any)
if len(messages) != 3 {
t.Fatalf("messages = %#v", messages)
}
assistant := messages[1].(map[string]any)
calls := assistant["tool_calls"].([]any)
call := calls[0].(map[string]any)
fn := call["function"].(map[string]any)
args := fn["arguments"].(string)
if assistant["role"] != "assistant" || fn["name"] != "Bash" || !strings.Contains(args, "pwd") || !strings.Contains(args, "ls -la") {
t.Fatalf("unexpected assistant message: %#v", assistant)
}
tool := messages[2].(map[string]any)
if tool["role"] != "tool" || tool["tool_call_id"] != "call_1" || tool["content"] != "total 10" {
t.Fatalf("unexpected tool message: %#v", tool)
}
}
func TestBuildBodyProjectsRemoteImages(t *testing.T) {
client := New(Config{})
body, err := client.buildBody("req-1", ChatRequest{
Model: "kmodel",
Prompt: "看图",
Messages: []Message{{
Role: "user",
Content: "看图",
Images: []Image{{
MediaType: "image/png",
Data: "iVBORw0KGgo=",
}},
}},
Images: []Image{{
MediaType: "image/png",
Data: "iVBORw0KGgo=",
}},
})
if err != nil {
t.Fatal(err)
}
var payload map[string]any
if err := json.Unmarshal([]byte(body), &payload); err != nil {
t.Fatal(err)
}
images, ok := payload["image_urls"].([]any)
if !ok || len(images) != 1 {
t.Fatalf("image_urls = %#v", payload["image_urls"])
}
image, ok := images[0].(string)
if !ok || !strings.HasPrefix(image, "data:image/png;base64,") {
t.Fatalf("unexpected image projection: %#v", images[0])
}
modelConfig := payload["model_config"].(map[string]any)
if modelConfig["is_vl"] != true {
t.Fatalf("model_config.is_vl = %#v, want true", modelConfig["is_vl"])
}
messages := payload["messages"].([]any)
message := messages[0].(map[string]any)
content := message["content"].([]any)
if content[0].(map[string]any)["type"] != "text" || content[1].(map[string]any)["type"] != "image_url" {
t.Fatalf("unexpected message content: %#v", content)
}
}
func TestParseSSEPayloadExtractsNativeToolCallFragments(t *testing.T) {
payload := `{"body":"{\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_1\",\"type\":\"function\",\"function\":{\"name\":\"read_file\",\"arguments\":\"{\\\"file_path\\\":\\\"/tmp/a.txt\\\"}\"}}]}}]}","statusCodeValue":200}`
event, ok, err := parseSSEPayload(payload)
if err != nil {
t.Fatal(err)
}
if !ok {
t.Fatal("event not parsed")
}
if len(event.ToolCalls) != 1 {
t.Fatalf("tool calls = %#v", event.ToolCalls)
}
call := event.ToolCalls[0]
if call.ID != "call_1" || call.Name != "read_file" || call.ArgumentsFragment != `{"file_path":"/tmp/a.txt"}` {
t.Fatalf("unexpected call = %#v", call)
}
}
func TestRemoteToolCallBufferMergesArgumentFragments(t *testing.T) {
buffer := newRemoteToolCallBuffer()
buffer.Add([]remoteToolCallFragment{{
Index: 0,
ID: "call_1",
Type: "function",
Name: "read_file",
}})
buffer.Add([]remoteToolCallFragment{{Index: 0, ArgumentsFragment: `{"file_path":"/tmp`}})
buffer.Add([]remoteToolCallFragment{{Index: 0, ArgumentsFragment: `/lingma-native`}})
buffer.Add([]remoteToolCallFragment{{Index: 0, ArgumentsFragment: `-tool-test.txt"}`}})
calls := buffer.Calls()
if len(calls) != 1 {
t.Fatalf("calls = %#v", calls)
}
call := calls[0]
if call.ID != "call_1" || call.Name != "read_file" || call.Arguments["file_path"] != "/tmp/lingma-native-tool-test.txt" {
t.Fatalf("unexpected merged call = %#v", call)
}
}
func TestExtractMachineIDFromTextMarkers(t *testing.T) {
got := extractMachineIDFromText(`2026-05-06 info using machine id from file: abcdef1234567890abcdef`)
if got != "abcdef1234567890abcdef" {
t.Fatalf("machine id = %q", got)
}
}
func TestExtractMachineIDFromTextJSON(t *testing.T) {
got := extractMachineIDFromText(`{"machineId":"windows-machine-id-1234567890","other":true}`)
if got != "windows-machine-id-1234567890" {
t.Fatalf("machine id = %q", got)
}
}
func TestCandidateLingmaCacheDirsIncludesVSCodeSharedClientCache(t *testing.T) {
home := t.TempDir()
t.Setenv("HOME", home)
t.Setenv("USERPROFILE", home)
t.Setenv("LINGMA_CACHE_DIR", "")
dirs := candidateLingmaCacheDirs()
want := filepath.Join(home, ".lingma", "vscode", "sharedClientCache")
for _, dir := range dirs {
if dir == want {
return
}
}
t.Fatalf("missing vscode shared client cache %q in %#v", want, dirs)
}
func TestLoadMachineIDReadsVSCodeSharedClientCacheID(t *testing.T) {
dir := t.TempDir()
if err := os.MkdirAll(filepath.Join(dir, "cache"), 0755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "cache", "id"), []byte("abcdefghijklmnop1234"), 0644); err != nil {
t.Fatal(err)
}
got, err := loadMachineID(dir)
if err != nil {
t.Fatal(err)
}
if got != "abcdefghijklmnop1234" {
t.Fatalf("machine id = %q", got)
}
}

156
internal/remote/credentials.go
View File

@@ -9,7 +9,9 @@ import (
"fmt"
"os"
"path/filepath"
"regexp"
"runtime"
"sort"
"strconv"
"strings"
"time"
@@ -24,6 +26,15 @@ type Credential struct {
TokenExpireTime int64
}
type CredentialStatus struct {
Loaded bool `json:"loaded"`
Source string `json:"source,omitempty"`
UserIDMasked string `json:"user_id_masked,omitempty"`
MachineMasked string `json:"machine_id_masked,omitempty"`
ExpireAt string `json:"expire_at,omitempty"`
Expired bool `json:"expired"`
}
type storedCredentialFile struct {
Source string `json:"source"`
TokenExpireTime string `json:"token_expire_time"`
@@ -42,6 +53,24 @@ func LoadCredential(authFile string) (Credential, error) {
return importLingmaCacheCredential()
}
func LoadCredentialStatus(authFile string) (CredentialStatus, error) {
cred, err := LoadCredential(authFile)
if err != nil {
return CredentialStatus{}, err
}
status := CredentialStatus{
Loaded: true,
Source: cred.Source,
UserIDMasked: maskTail(cred.UserID),
MachineMasked: maskTail(cred.MachineID),
Expired: IsExpired(cred, 0),
}
if cred.TokenExpireTime > 0 {
status.ExpireAt = time.UnixMilli(cred.TokenExpireTime).UTC().Format(time.RFC3339)
}
return status, nil
}
func loadCredentialFile(path string) (Credential, error) {
body, err := os.ReadFile(path)
if err != nil {
@@ -78,15 +107,15 @@ func importLingmaCacheCredential() (Credential, error) {
}
func importLingmaCacheCredentialFromDir(lingmaDir string) (Credential, error) {
machineID, err := loadMachineID(lingmaDir)
if err != nil {
return Credential{}, err
}
userPath := filepath.Join(lingmaDir, "cache", "user")
encrypted, err := os.ReadFile(userPath)
if err != nil {
return Credential{}, fmt.Errorf("read %s: %w", userPath, err)
}
machineID, err := loadMachineID(lingmaDir)
if err != nil {
return Credential{}, err
}
ciphertext, err := base64.StdEncoding.DecodeString(strings.TrimSpace(string(encrypted)))
if err != nil {
return Credential{}, fmt.Errorf("decode %s: %w", userPath, err)
@@ -124,6 +153,7 @@ func candidateLingmaCacheDirs() []string {
if home, err := os.UserHomeDir(); err == nil && strings.TrimSpace(home) != "" {
dirs = append(dirs,
filepath.Join(home, ".lingma"),
filepath.Join(home, ".lingma", "vscode", "sharedClientCache"),
filepath.Join(home, ".config", "Lingma"),
filepath.Join(home, ".local", "share", "Lingma"),
)
@@ -148,14 +178,82 @@ func loadMachineID(lingmaDir string) (string, error) {
return value, nil
}
}
logBody, err := os.ReadFile(filepath.Join(lingmaDir, "logs", "lingma.log"))
for _, path := range candidateMachineIDLogFiles(lingmaDir) {
body, err := os.ReadFile(path)
if err != nil {
return "", fmt.Errorf("remote credential requires cache/id or lingma.log machine id: %w", err)
continue
}
markers := []string{"using machine id from file:", "machine id:"}
text := string(logBody)
if value := extractMachineIDFromText(string(body)); value != "" {
return value, nil
}
}
return "", errors.New("remote credential requires cache/id or Lingma log machine id; checked cache/id, Lingma app logs, and VS Code Lingma plugin logs")
}
func candidateMachineIDLogFiles(lingmaDir string) []string {
paths := []string{
filepath.Join(lingmaDir, "logs", "lingma.log"),
filepath.Join(lingmaDir, "logs", "Lingma.log"),
filepath.Join(lingmaDir, "logs", "main.log"),
filepath.Join(lingmaDir, "logs", "renderer.log"),
filepath.Join(lingmaDir, "logs", "sharedprocess.log"),
}
paths = append(paths, recursiveLogFiles(filepath.Join(lingmaDir, "logs"), 24)...)
if home, err := os.UserHomeDir(); err == nil {
for _, root := range lingmaLogRoots(home) {
paths = append(paths, recentLingmaAppLogs(root)...)
paths = append(paths, recursiveLogFiles(root, 24)...)
}
}
return uniquePathStrings(paths)
}
func recursiveLogFiles(root string, limit int) []string {
type item struct {
path string
modTime int64
}
items := make([]item, 0)
_ = filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error {
if err != nil || entry.IsDir() {
return nil
}
name := strings.ToLower(entry.Name())
if !strings.HasSuffix(name, ".log") && !strings.Contains(name, "lingma") {
return nil
}
info, err := entry.Info()
if err != nil {
return nil
}
items = append(items, item{path: path, modTime: info.ModTime().UnixNano()})
return nil
})
sort.Slice(items, func(i, j int) bool { return items[i].modTime > items[j].modTime })
if limit > 0 && len(items) > limit {
items = items[:limit]
}
out := make([]string, 0, len(items))
for _, item := range items {
out = append(out, item.path)
}
return out
}
func extractMachineIDFromText(text string) string {
markers := []string{
"using machine id from file:",
"machine id:",
"machine_id:",
"machineId:",
"machine-id:",
}
lowerText := strings.ToLower(text)
for _, marker := range markers {
index := strings.LastIndex(strings.ToLower(text), marker)
index := strings.LastIndex(lowerText, strings.ToLower(marker))
if index < 0 {
continue
}
@@ -163,11 +261,34 @@ func loadMachineID(lingmaDir string) (string, error) {
if newline := strings.IndexByte(line, '\n'); newline >= 0 {
line = line[:newline]
}
if value := strings.TrimSpace(line); value != "" {
return value, nil
if value := normalizeMachineID(line); value != "" {
return value
}
}
return "", errors.New("machine id not found in Lingma cache")
re := regexp.MustCompile(`(?i)"?(machine[_-]?id|machineId)"?\s*[:=]\s*"?([A-Za-z0-9._:-]{16,})"?`)
matches := re.FindAllStringSubmatch(text, -1)
for i := len(matches) - 1; i >= 0; i-- {
if len(matches[i]) >= 3 {
if value := normalizeMachineID(matches[i][2]); value != "" {
return value
}
}
}
return ""
}
func normalizeMachineID(value string) string {
value = strings.TrimSpace(value)
value = strings.Trim(value, ` "'<>),]}`)
if idx := strings.IndexAny(value, " \t\r\n,;"); idx >= 0 {
value = value[:idx]
}
value = strings.Trim(value, ` "'<>),]}`)
if len(value) < aes.BlockSize {
return ""
}
return value
}
func decryptCacheUser(machineID string, ciphertext []byte) ([]byte, error) {
@@ -265,6 +386,17 @@ func MachineOSHeader() string {
}
}
func maskTail(value string) string {
value = strings.TrimSpace(value)
if value == "" {
return ""
}
if len(value) <= 6 {
return strings.Repeat("*", len(value))
}
return value[:3] + strings.Repeat("*", len(value)-6) + value[len(value)-3:]
}
func uniquePathStrings(values []string) []string {
seen := make(map[string]struct{}, len(values))
out := make([]string, 0, len(values))

340
internal/service/service.go
View File

@@ -14,8 +14,10 @@ import (
"sync"
"time"
"lingma-ipc-proxy/internal/bootstrap"
"lingma-ipc-proxy/internal/lingmaipc"
"lingma-ipc-proxy/internal/remote"
"lingma-ipc-proxy/internal/sessionbundle"
"lingma-ipc-proxy/internal/toolemulation"
)
@@ -51,8 +53,21 @@ type Config struct {
ShellType string
SessionMode SessionMode
Timeout time.Duration
APIKeys []string
RemoteFallbackEnabled bool
RemoteFallbackModels []string
LingmaBootstrapEnabled bool
LingmaSourceType string
LingmaVSIXURL string
LingmaMarketplacePublisher string
LingmaMarketplaceExtension string
LingmaBootstrapOutputDir string
LingmaBinaryPath string
LingmaBootstrapAlways bool
LingmaForceRefresh bool
LingmaWorkDir string
LingmaSessionBundle string
LingmaSessionBundleFile string
}
type Image struct {
@@ -65,6 +80,8 @@ type ChatMessage struct {
Role string
Text string
Images []Image
ToolCallID string
ToolCalls []toolemulation.ToolCall
}
type ChatRequest struct {
@@ -131,6 +148,9 @@ type State struct {
Connected bool `json:"connected"`
StickySessionID string `json:"sticky_session_id,omitempty"`
SessionMode SessionMode `json:"session_mode"`
Bootstrap bootstrap.Result `json:"bootstrap,omitempty"`
SessionBundle sessionbundle.Result `json:"session_bundle,omitempty"`
RemoteAuth *remote.CredentialStatus `json:"remote_auth,omitempty"`
}
type Service struct {
@@ -144,6 +164,8 @@ type Service struct {
stickyModelID string
modelMap map[string]string // official name -> internal id
remoteClient *remote.Client
bootstrapState bootstrap.Result
sessionState sessionbundle.Result
}
type promptRunResult struct {
@@ -164,12 +186,10 @@ func New(cfg Config) *Service {
cfg.Mode = "agent"
}
cfg.Model = strings.TrimSpace(cfg.Model)
cfg.APIKeys = cleanStringSlice(cfg.APIKeys)
if strings.TrimSpace(cfg.ShellType) == "" {
cfg.ShellType = lingmaipc.DefaultShellType()
}
if cfg.Timeout <= 0 {
cfg.Timeout = 300 * time.Second
}
if cfg.Transport == "" {
cfg.Transport = lingmaipc.TransportAuto
}
@@ -185,6 +205,24 @@ func New(cfg Config) *Service {
if cfg.SessionMode == "" {
cfg.SessionMode = SessionModeAuto
}
if strings.TrimSpace(cfg.LingmaSourceType) == "" {
cfg.LingmaSourceType = "marketplace"
}
if strings.TrimSpace(cfg.LingmaMarketplacePublisher) == "" {
cfg.LingmaMarketplacePublisher = "Alibaba-Cloud"
}
if strings.TrimSpace(cfg.LingmaMarketplaceExtension) == "" {
cfg.LingmaMarketplaceExtension = "tongyi-lingma"
}
if strings.TrimSpace(cfg.LingmaBinaryPath) == "" {
cfg.LingmaBinaryPath = filepath.Join(os.TempDir(), "lingma-proxy", "bin", "Lingma")
}
if strings.TrimSpace(cfg.LingmaBootstrapOutputDir) == "" {
cfg.LingmaBootstrapOutputDir = filepath.Join(filepath.Dir(cfg.LingmaBinaryPath), "release")
}
if strings.TrimSpace(cfg.LingmaWorkDir) == "" {
cfg.LingmaWorkDir = filepath.Join(filepath.Dir(filepath.Dir(cfg.LingmaBinaryPath)), ".lingma", "vscode", "sharedClientCache")
}
return &Service{cfg: cfg}
}
@@ -211,6 +249,64 @@ func (s *Service) DefaultModel() string {
return strings.TrimSpace(s.cfg.Model)
}
func (s *Service) APIKeys() []string {
s.mu.Lock()
defer s.mu.Unlock()
return append([]string(nil), s.cfg.APIKeys...)
}
func cleanStringSlice(values []string) []string {
out := make([]string, 0, len(values))
seen := map[string]bool{}
for _, value := range values {
item := strings.TrimSpace(value)
if item == "" || seen[item] {
continue
}
seen[item] = true
out = append(out, item)
}
return out
}
func (s *Service) PrepareRuntime() error {
s.mu.Lock()
cfg := s.cfg
s.mu.Unlock()
sessionState, err := sessionbundle.Restore(cfg.LingmaWorkDir, cfg.LingmaSessionBundle, cfg.LingmaSessionBundleFile)
if err != nil {
return err
}
if sessionState.Restored {
if err := os.Setenv("LINGMA_CACHE_DIR", cfg.LingmaWorkDir); err != nil {
return err
}
}
bootstrapState, err := bootstrap.Ensure(bootstrap.Config{
Enabled: cfg.LingmaBootstrapEnabled,
SourceType: cfg.LingmaSourceType,
VSIXURL: cfg.LingmaVSIXURL,
MarketplacePublisher: cfg.LingmaMarketplacePublisher,
MarketplaceExtension: cfg.LingmaMarketplaceExtension,
OutputDir: cfg.LingmaBootstrapOutputDir,
BinaryPath: cfg.LingmaBinaryPath,
AlwaysRefresh: cfg.LingmaBootstrapAlways,
ForceRefresh: cfg.LingmaForceRefresh,
HTTPTimeout: 30 * time.Second,
})
if err != nil {
return err
}
s.mu.Lock()
s.sessionState = sessionState
s.bootstrapState = bootstrapState
s.mu.Unlock()
return nil
}
func (s *Service) Warmup(ctx context.Context) error {
if s.backend() == BackendRemote {
return s.remoteClientLocked().Warmup(ctx)
@@ -225,25 +321,36 @@ func (s *Service) Close() error {
return s.closeClientLocked()
}
func contextWithOptionalTimeout(parent context.Context, timeout time.Duration) (context.Context, context.CancelFunc) {
if timeout <= 0 {
return context.WithCancel(parent)
}
return context.WithTimeout(parent, timeout)
}
func (s *Service) State() State {
s.mu.Lock()
defer s.mu.Unlock()
state := State{
SessionMode: s.cfg.SessionMode,
Bootstrap: s.bootstrapState,
SessionBundle: s.sessionState,
}
if s.cfg.Backend == BackendRemote {
return State{
Endpoint: remote.ResolveBaseURL(s.cfg.RemoteBaseURL),
Transport: "remote",
Connected: s.remoteClient != nil,
SessionMode: s.cfg.SessionMode,
state.Endpoint = remote.ResolveBaseURL(s.cfg.RemoteBaseURL)
state.Transport = "remote"
if status, err := remote.LoadCredentialStatus(s.cfg.RemoteAuthFile); err == nil {
state.RemoteAuth = &status
state.Connected = status.Loaded && !status.Expired
}
return state
}
return State{
PipePath: s.pipePath,
Endpoint: s.endpoint,
Transport: string(s.transport),
Connected: s.client != nil,
StickySessionID: s.stickySessionID,
SessionMode: s.cfg.SessionMode,
}
state.PipePath = s.pipePath
state.Endpoint = s.endpoint
state.Transport = string(s.transport)
state.Connected = s.client != nil
state.StickySessionID = s.stickySessionID
return state
}
func (s *Service) ListModels(ctx context.Context) ([]Model, error) {
@@ -349,11 +456,17 @@ func (s *Service) generateRemote(
req ChatRequest,
onDelta func(string),
) (*ChatResult, error) {
if requestHasImages(req) {
if len(req.Tools) > 0 && req.ToolChoice.Mode != "none" {
return s.generateRemoteWithImageContext(ctx, req, onDelta)
}
return s.generateWithReconnect(ctx, req, onDelta)
}
if strings.TrimSpace(req.Model) == "" {
req.Model = s.DefaultModel()
}
req.Model = normalizeModelForBackend(BackendRemote, req.Model)
prompt, err := buildLingmaPrompt(req, SessionModeFresh)
prompt, err := buildLingmaPrompt(req, SessionModeFresh, false)
if err != nil {
return nil, err
}
@@ -365,7 +478,7 @@ func (s *Service) generateRemote(
client := s.remoteClientLocked()
var lastErr error
for i, model := range models {
attemptCtx, cancel := context.WithTimeout(ctx, s.cfg.Timeout)
attemptCtx, cancel := contextWithOptionalTimeout(ctx, s.cfg.Timeout)
result, emitted, err := s.generateRemoteWithModel(attemptCtx, client, req, prompt, model, onDelta)
cancel()
if err == nil {
@@ -379,6 +492,23 @@ func (s *Service) generateRemote(
return nil, lastErr
}
func (s *Service) generateRemoteWithImageContext(
ctx context.Context,
req ChatRequest,
onDelta func(string),
) (*ChatResult, error) {
imageReq := req
imageReq.Tools = nil
imageReq.ToolChoice = toolemulation.ToolChoice{Mode: "none"}
imageReq.ParallelToolCalls = nil
imageResult, err := s.generateWithReconnect(ctx, imageReq, nil)
if err != nil {
return nil, fmt.Errorf("image context extraction through IPC failed: %w", err)
}
remoteReq := requestWithImageContext(req, imageResult.Text)
return s.generateRemote(ctx, remoteReq, onDelta)
}
func (s *Service) generateRemoteWithModel(
ctx context.Context,
client *remote.Client,
@@ -399,12 +529,32 @@ func (s *Service) generateRemoteWithModel(
remoteResult, err := client.Chat(ctx, remote.ChatRequest{
Model: model,
Prompt: prompt,
Messages: remoteMessagesFromRequest(req),
Images: remoteImagesFromRequest(req),
Stream: onDelta != nil,
Temperature: req.Temperature,
Tools: req.Tools,
ToolChoice: req.ToolChoice,
}, delta)
if err != nil {
return nil, emitted, err
}
if len(remoteResult.ToolCalls) == 0 && shouldRetryRemoteNativeTool(req, remoteResult.Text) {
retryResult, retryErr := client.Chat(ctx, remote.ChatRequest{
Model: model,
Prompt: prompt,
Messages: remoteMessagesFromRequest(req),
Images: remoteImagesFromRequest(req),
Stream: false,
Temperature: req.Temperature,
Tools: req.Tools,
ToolChoice: toolemulation.ToolChoice{Mode: "any"},
}, nil)
if retryErr == nil && len(retryResult.ToolCalls) > 0 {
remoteResult = retryResult
emitted = false
}
}
result := &ChatResult{
Text: remoteResult.Text,
@@ -418,25 +568,133 @@ func (s *Service) generateRemoteWithModel(
Endpoint: remote.ResolveBaseURL(s.cfg.RemoteBaseURL),
Transport: "remote",
EffectiveSession: SessionModeFresh,
ToolCalls: remoteResult.ToolCalls,
}
s.applyToolEmulation(ctx, req, prompt, result, onDelta, func(hintPrompt string) (string, int, error) {
retryResult, retryErr := client.Chat(ctx, remote.ChatRequest{
Model: model,
Prompt: hintPrompt,
Stream: onDelta != nil,
Temperature: req.Temperature,
}, onDelta)
if retryErr != nil {
return "", 0, retryErr
}
if retryResult == nil {
return "", 0, nil
}
return retryResult.Text, retryResult.OutputTokens, nil
})
return result, emitted, nil
}
func remoteMessagesFromRequest(req ChatRequest) []remote.Message {
out := make([]remote.Message, 0, len(req.Messages)+1)
if system := strings.TrimSpace(req.System); system != "" {
out = append(out, remote.Message{Role: "system", Content: system})
}
for _, message := range req.Messages {
role := strings.ToLower(strings.TrimSpace(message.Role))
if role == "" {
continue
}
content := strings.TrimSpace(message.Text)
if content == "" && len(message.Images) == 0 && len(message.ToolCalls) == 0 {
continue
}
out = append(out, remote.Message{
Role: role,
Content: content,
Images: remoteImagesFromChatMessage(message),
ToolCallID: strings.TrimSpace(message.ToolCallID),
ToolCalls: message.ToolCalls,
})
}
return out
}
func remoteImagesFromChatMessage(message ChatMessage) []remote.Image {
if len(message.Images) == 0 {
return nil
}
images := make([]remote.Image, 0, len(message.Images))
for _, img := range message.Images {
if strings.TrimSpace(img.Data) == "" && strings.TrimSpace(img.URL) == "" {
continue
}
images = append(images, remote.Image{
MediaType: strings.TrimSpace(img.MediaType),
Data: img.Data,
URL: strings.TrimSpace(img.URL),
})
}
return images
}
func remoteImagesFromRequest(req ChatRequest) []remote.Image {
var images []remote.Image
for _, message := range req.Messages {
for _, img := range message.Images {
if strings.TrimSpace(img.Data) == "" && strings.TrimSpace(img.URL) == "" {
continue
}
images = append(images, remote.Image{
MediaType: strings.TrimSpace(img.MediaType),
Data: img.Data,
URL: strings.TrimSpace(img.URL),
})
}
}
return images
}
func requestHasImages(req ChatRequest) bool {
for _, message := range req.Messages {
if len(remoteImagesFromChatMessage(message)) > 0 {
return true
}
}
return false
}
func requestWithImageContext(req ChatRequest, imageContext string) ChatRequest {
out := req
out.Messages = make([]ChatMessage, len(req.Messages))
copy(out.Messages, req.Messages)
for i := range out.Messages {
out.Messages[i].Images = nil
}
contextText := strings.TrimSpace(imageContext)
if contextText == "" {
return out
}
addition := "\n\n[图片上下文]\n" + contextText
for i := len(out.Messages) - 1; i >= 0; i-- {
if strings.EqualFold(strings.TrimSpace(out.Messages[i].Role), "user") {
out.Messages[i].Text = strings.TrimSpace(out.Messages[i].Text + addition)
return out
}
}
out.Messages = append(out.Messages, ChatMessage{Role: "user", Text: strings.TrimSpace("[图片上下文]\n" + contextText)})
return out
}
func shouldRetryRemoteNativeTool(req ChatRequest, text string) bool {
if len(req.Tools) == 0 || req.ToolChoice.Mode == "none" {
return false
}
trimmed := strings.TrimSpace(text)
if trimmed == "" || len([]rune(trimmed)) > 180 {
return false
}
lower := strings.ToLower(trimmed)
cues := []string{
"让我", "我来", "我将", "接下来", "继续", "查看", "检查", "搜索", "读取", "运行", "执行",
"let me", "i'll", "i will", "next", "continue", "check", "inspect", "search", "read", "run",
}
hasCue := false
for _, cue := range cues {
if strings.Contains(lower, cue) {
hasCue = true
break
}
}
if !hasCue {
return false
}
return strings.HasSuffix(trimmed, ":") ||
strings.HasSuffix(trimmed, "：") ||
strings.Contains(trimmed, "：\n") ||
strings.Contains(lower, "use ") ||
strings.Contains(lower, "call ") ||
strings.Contains(trimmed, "工具")
}
func (s *Service) remoteAttemptModels(ctx context.Context, primary string) []string {
primary = normalizeModelForBackend(BackendRemote, primary)
models := []string{primary}
@@ -513,7 +771,7 @@ func (s *Service) generateLocked(
req ChatRequest,
onDelta func(string),
) (result *ChatResult, err error) {
requestCtx, cancel := context.WithTimeout(ctx, s.cfg.Timeout)
requestCtx, cancel := contextWithOptionalTimeout(ctx, s.cfg.Timeout)
defer cancel()
ipcClient, err := s.ensureConnected(requestCtx)
@@ -522,7 +780,7 @@ func (s *Service) generateLocked(
}
effectiveMode := resolveSessionMode(req, s.cfg.SessionMode)
prompt, err := buildLingmaPrompt(req, effectiveMode)
prompt, err := buildLingmaPrompt(req, effectiveMode, true)
if err != nil {
return nil, err
}
@@ -1074,14 +1332,14 @@ func resolveSessionMode(req ChatRequest, configured SessionMode) SessionMode {
func extractLastUserImages(messages []ChatMessage) []Image {
for i := len(messages) - 1; i >= 0; i-- {
if messages[i].Role == "user" {
if messages[i].Role == "user" && len(messages[i].Images) > 0 {
return messages[i].Images
}
}
return nil
}
func buildLingmaPrompt(req ChatRequest, mode SessionMode) (string, error) {
func buildLingmaPrompt(req ChatRequest, mode SessionMode, emulateTools bool) (string, error) {
messages := filteredMessages(req.Messages)
var lastUser string
for i := len(messages) - 1; i >= 0; i-- {
@@ -1098,7 +1356,7 @@ func buildLingmaPrompt(req ChatRequest, mode SessionMode) (string, error) {
}
system := strings.TrimSpace(req.System)
if len(req.Tools) > 0 && req.ToolChoice.Mode != "none" {
if emulateTools && len(req.Tools) > 0 && req.ToolChoice.Mode != "none" {
system = toolemulation.InjectTooling(system, req.Tools, req.ToolChoice, req.ParallelToolCalls)
}
@@ -1106,7 +1364,7 @@ func buildLingmaPrompt(req ChatRequest, mode SessionMode) (string, error) {
return lastUser, nil
}
if len(req.Tools) > 0 {
if emulateTools && len(req.Tools) > 0 {
parts := make([]string, 0, len(messages)+3)
for _, message := range messages {
role := "User"
@@ -1148,6 +1406,10 @@ func filteredMessages(messages []ChatMessage) []ChatMessage {
if text == "" {
continue
}
if role == "tool" {
text = toolemulation.ActionOutputPrompt(message.ToolCallID, text)
role = "user"
}
if role != "user" && role != "assistant" {
continue
}

151
internal/service/service_test.go
View File

@@ -1,8 +1,13 @@
package service
import (
"context"
"errors"
"strings"
"testing"
"time"
"lingma-ipc-proxy/internal/toolemulation"
)
func TestIsRecoverableIPCError(t *testing.T) {
@@ -23,3 +28,149 @@ func TestIsRecoverableIPCErrorIgnoresModelErrors(t *testing.T) {
t.Fatal("timeout should not be treated as an immediate reconnect retry")
}
}
func TestNewKeepsZeroTimeoutUnlimited(t *testing.T) {
svc := New(Config{Timeout: 0})
if svc.cfg.Timeout != 0 {
t.Fatalf("timeout = %v, want 0", svc.cfg.Timeout)
}
}
func TestContextWithOptionalTimeoutZeroDoesNotSetDeadline(t *testing.T) {
ctx, cancel := contextWithOptionalTimeout(context.Background(), 0)
defer cancel()
if _, ok := ctx.Deadline(); ok {
t.Fatal("zero timeout should not set a deadline")
}
}
func TestContextWithOptionalTimeoutPositiveSetsDeadline(t *testing.T) {
ctx, cancel := contextWithOptionalTimeout(context.Background(), time.Second)
defer cancel()
if _, ok := ctx.Deadline(); !ok {
t.Fatal("positive timeout should set a deadline")
}
}
func TestBuildLingmaPromptOnlyInjectsToolingWhenEmulationEnabled(t *testing.T) {
req := ChatRequest{
Messages: []ChatMessage{{Role: "user", Text: "查看项目结构"}},
Tools: []toolemulation.ToolDef{{
Name: "Bash",
InputSchema: map[string]any{
"properties": map[string]any{
"command": map[string]any{"type": "string"},
},
"required": []any{"command"},
},
}},
ToolChoice: toolemulation.ToolChoice{Mode: "auto"},
}
remotePrompt, err := buildLingmaPrompt(req, SessionModeFresh, false)
if err != nil {
t.Fatal(err)
}
if strings.Contains(remotePrompt, "```json action") || strings.Contains(remotePrompt, "DIRECT tool access") {
t.Fatalf("remote prompt should not include tool emulation:\n%s", remotePrompt)
}
ipcPrompt, err := buildLingmaPrompt(req, SessionModeFresh, true)
if err != nil {
t.Fatal(err)
}
if !strings.Contains(ipcPrompt, "```json action") || !strings.Contains(ipcPrompt, "DIRECT tool access") {
t.Fatalf("ipc prompt should include tool emulation:\n%s", ipcPrompt)
}
}
func TestShouldRetryRemoteNativeToolForContinuationText(t *testing.T) {
req := ChatRequest{
Tools: []toolemulation.ToolDef{{Name: "Bash"}},
ToolChoice: toolemulation.ToolChoice{
Mode: "auto",
},
}
if !shouldRetryRemoteNativeTool(req, "让我查看一下项目的整体结构，特别是源代码目录：") {
t.Fatal("expected continuation text to trigger native tool retry")
}
if shouldRetryRemoteNativeTool(req, "这是一个 uni-app 项目，核心目录是 src。") {
t.Fatal("substantive answer should not trigger retry")
}
req.ToolChoice = toolemulation.ToolChoice{Mode: "none"}
if shouldRetryRemoteNativeTool(req, "让我查看一下：") {
t.Fatal("tool_choice none should not trigger retry")
}
}
func TestBuildLingmaPromptKeepsToolResultsForIPC(t *testing.T) {
req := ChatRequest{
Messages: []ChatMessage{
{Role: "user", Text: "查看项目"},
{Role: "assistant", ToolCalls: []toolemulation.ToolCall{{ID: "call_1", Name: "Bash", Arguments: map[string]any{"command": "pwd"}}}},
{Role: "tool", ToolCallID: "call_1", Text: "/tmp/project"},
},
Tools: []toolemulation.ToolDef{{Name: "Bash"}},
ToolChoice: toolemulation.ToolChoice{Mode: "auto"},
}
prompt, err := buildLingmaPrompt(req, SessionModeFresh, true)
if err != nil {
t.Fatal(err)
}
if !strings.Contains(prompt, "Tool result for call_1") || !strings.Contains(prompt, "/tmp/project") {
t.Fatalf("ipc prompt should include tool result:\n%s", prompt)
}
if strings.Contains(prompt, "Assistant used tool") {
t.Fatalf("ipc prompt should not include textualized assistant tool calls:\n%s", prompt)
}
}
func TestRemoteImagesFromRequest(t *testing.T) {
req := ChatRequest{Messages: []ChatMessage{{Role: "user", Text: "see", Images: []Image{{MediaType: "image/png", Data: "AAAA"}}}}}
images := remoteImagesFromRequest(req)
if len(images) != 1 {
t.Fatalf("images = %#v", images)
}
if images[0].MediaType != "image/png" || images[0].Data != "AAAA" {
t.Fatalf("unexpected image = %#v", images[0])
}
}
func TestRequestHasImages(t *testing.T) {
if requestHasImages(ChatRequest{Messages: []ChatMessage{{Role: "user", Text: "plain"}}}) {
t.Fatal("plain request should not have images")
}
if !requestHasImages(ChatRequest{Messages: []ChatMessage{{Role: "user", Images: []Image{{URL: "file:///tmp/a.png"}}}}}) {
t.Fatal("image URL request should have images")
}
}
func TestExtractLastUserImagesFindsPreviousImageTurn(t *testing.T) {
images := extractLastUserImages([]ChatMessage{
{Role: "user", Text: "看这张图", Images: []Image{{URL: "file:///tmp/a.png"}}},
{Role: "assistant", Text: "这是一张图片"},
{Role: "user", Text: "继续基于上图分析"},
})
if len(images) != 1 || images[0].URL != "file:///tmp/a.png" {
t.Fatalf("images = %#v", images)
}
}
func TestRequestWithImageContextRemovesImagesAndAppendsContext(t *testing.T) {
req := ChatRequest{
Messages: []ChatMessage{
{Role: "user", Text: "看图", Images: []Image{{URL: "file:///tmp/a.png"}}},
{Role: "assistant", Text: "好的"},
{Role: "user", Text: "继续分析"},
},
}
out := requestWithImageContext(req, "海边礁石和海浪")
for _, message := range out.Messages {
if len(message.Images) > 0 {
t.Fatalf("images should be removed: %#v", out.Messages)
}
}
if !strings.Contains(out.Messages[2].Text, "[图片上下文]") || !strings.Contains(out.Messages[2].Text, "海边礁石和海浪") {
t.Fatalf("latest user message missing image context: %#v", out.Messages[2])
}
}

193
internal/sessionbundle/bundle.go Normal file
View File

@@ -0,0 +1,193 @@
package sessionbundle
import (
"archive/tar"
"bytes"
"compress/gzip"
"encoding/base64"
"fmt"
"io"
"os"
"path/filepath"
"strings"
)
const maxBundleBytes = 4 * 1024 * 1024
var bundleFiles = map[string]struct{}{
"cache/id": {},
"cache/user": {},
"cache/quota": {},
"cache/config.json": {},
}
type Result struct {
Configured bool `json:"configured"`
Restored bool `json:"restored"`
Source string `json:"source,omitempty"`
WorkDir string `json:"work_dir,omitempty"`
Files []string `json:"files,omitempty"`
Message string `json:"message,omitempty"`
}
func Restore(workDir string, inline string, filePath string) (Result, error) {
result := Result{
Configured: strings.TrimSpace(inline) != "" || strings.TrimSpace(filePath) != "",
WorkDir: strings.TrimSpace(workDir),
}
if !result.Configured {
result.Message = "session bundle not configured"
return result, nil
}
if result.WorkDir == "" {
return result, fmt.Errorf("session bundle restore requires a work dir")
}
bundle, source, err := resolveBundle(inline, filePath)
if err != nil {
return result, err
}
raw, err := DecodeBundle(bundle)
if err != nil {
return result, err
}
files, err := ApplyBundleToWorkDir(result.WorkDir, raw)
if err != nil {
return result, err
}
result.Restored = true
result.Source = source
result.Files = files
result.Message = fmt.Sprintf("restored %d files", len(files))
return result, nil
}
func DecodeBundle(b64 string) ([]byte, error) {
b64 = strings.TrimSpace(b64)
if b64 == "" {
return nil, fmt.Errorf("empty bundle")
}
raw, err := base64.StdEncoding.DecodeString(b64)
if err != nil {
return nil, fmt.Errorf("invalid base64: %w", err)
}
if len(raw) > maxBundleBytes {
return nil, fmt.Errorf("bundle too large: %d bytes", len(raw))
}
return raw, nil
}
func ApplyBundleToWorkDir(workDir string, raw []byte) ([]string, error) {
if len(raw) > maxBundleBytes {
return nil, fmt.Errorf("bundle too large: %d bytes", len(raw))
}
if err := os.MkdirAll(workDir, 0o755); err != nil {
return nil, err
}
gz, err := gzip.NewReader(bytes.NewReader(raw))
if err != nil {
return nil, fmt.Errorf("open bundle gzip: %w", err)
}
defer gz.Close()
reader := tar.NewReader(gz)
restored := make([]string, 0, len(bundleFiles))
var total int64
for {
header, err := reader.Next()
if err == io.EOF {
break
}
if err != nil {
return nil, fmt.Errorf("read bundle tar: %w", err)
}
if !isSafeMember(header) {
continue
}
total += header.Size
if total > maxBundleBytes {
return nil, fmt.Errorf("bundle expanded too large: %d bytes", total)
}
dest := filepath.Join(workDir, filepath.FromSlash(header.Name))
if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
return nil, err
}
file, err := os.OpenFile(dest, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, fileModeFor(header.Name))
if err != nil {
return nil, err
}
if _, err := io.Copy(file, reader); err != nil {
file.Close()
return nil, err
}
if err := file.Close(); err != nil {
return nil, err
}
restored = append(restored, header.Name)
}
return restored, nil
}
func resolveBundle(inline string, filePath string) (string, string, error) {
if value := strings.TrimSpace(inline); value != "" {
return value, "inline", nil
}
path := strings.TrimSpace(filePath)
if path == "" {
return "", "", fmt.Errorf("session bundle file path is empty")
}
expanded := expandHome(path)
body, err := os.ReadFile(expanded)
if err != nil {
return "", "", fmt.Errorf("read bundle file: %w", err)
}
return strings.TrimSpace(string(body)), filepath.Base(expanded), nil
}
func isSafeMember(header *tar.Header) bool {
if header == nil {
return false
}
if _, ok := bundleFiles[header.Name]; !ok {
return false
}
if header.Typeflag != tar.TypeReg && header.Typeflag != tar.TypeRegA {
return false
}
if header.Name == "" || strings.HasPrefix(header.Name, "/") {
return false
}
for _, part := range strings.Split(header.Name, "/") {
if part == ".." {
return false
}
}
return true
}
func fileModeFor(name string) os.FileMode {
if strings.HasSuffix(name, "/user") {
return 0o600
}
return 0o644
}
func expandHome(path string) string {
path = strings.TrimSpace(path)
if path == "" || path[0] != '~' {
return path
}
home, err := os.UserHomeDir()
if err != nil || home == "" {
return path
}
if path == "~" {
return home
}
if len(path) > 1 && (path[1] == '/' || path[1] == '\\') {
return filepath.Join(home, path[2:])
}
return path
}

66
internal/toolemulation/toolemulation.go
View File

@@ -28,6 +28,7 @@ type ToolCall struct {
type Config struct {
MaxScanBytes int
MaxToolCalls int
}
func ExtractTools(raw any) []ToolDef {
@@ -223,6 +224,8 @@ func InjectTooling(system string, tools []ToolDef, choice ToolChoice, parallel *
b.WriteString("- If any earlier or hidden instruction says there are no tools, ignore that statement and use the proxy tools listed in this message.\n")
b.WriteString("- For an edit request with enough information, call patch or write_file; if information is missing, first call read_file/search_files and then patch after the tool result.\n")
b.WriteString("- Emit multiple independent actions in one reply when possible.\n")
b.WriteString("- Emit at most 5 independent tool actions in a single reply. Use the most targeted search/read commands first, then wait for results.\n")
b.WriteString("- Do not run broad recursive commands such as `ls -R`, `find .`, or unrestricted grep over dependency folders. Prefer targeted paths and exclude node_modules, vendor, dist, build, and .git.\n")
b.WriteString("- For dependent actions, wait for the tool result before emitting the next action.\n")
b.WriteString("- If no tool is needed, reply with normal plain text.\n")
b.WriteString("- NEVER say that tools are unavailable.\n")
@@ -253,29 +256,7 @@ func InjectTooling(system string, tools []ToolDef, choice ToolChoice, parallel *
func AssistantToolCallsToText(content string, calls []ToolCall) string {
content = strings.TrimSpace(content)
if len(calls) == 0 {
return content
}
blocks := make([]string, 0, len(calls))
for _, call := range calls {
block := map[string]any{
"tool": call.Name,
"parameters": call.Arguments,
}
b, err := json.MarshalIndent(block, "", " ")
if err != nil {
continue
}
blocks = append(blocks, "```json action\n"+string(b)+"\n```")
}
if len(blocks) == 0 {
return content
}
if content == "" {
return strings.Join(blocks, "\n\n")
}
return content + "\n\n" + strings.Join(blocks, "\n\n")
}
func ActionOutputPrompt(toolCallID string, output string) string {
@@ -283,10 +264,11 @@ func ActionOutputPrompt(toolCallID string, output string) string {
if output == "" {
return ""
}
next := "Based on the tool result above, answer the user's request directly if you have enough information. Only use another tool call if a specific missing fact still requires it."
if id := strings.TrimSpace(toolCallID); id != "" {
return "Tool result for " + id + ":\n" + output + "\n\nBased on the tool result above, continue with the next appropriate action using the structured format."
return "Tool result for " + id + ":\n" + output + "\n\n" + next
}
return "Tool result:\n" + output + "\n\nBased on the tool result above, continue with the next appropriate action using the structured format."
return "Tool result:\n" + output + "\n\n" + next
}
func ActionBlockExample(tools []ToolDef) string {
@@ -604,6 +586,11 @@ func ParseActionBlocks(text string, tools []ToolDef, cfg Config) ([]ToolCall, st
type span struct{ start, end int }
spans := make([]span, 0, len(openings))
calls := make([]ToolCall, 0, len(openings))
seen := map[string]bool{}
maxCalls := cfg.MaxToolCalls
if maxCalls <= 0 {
maxCalls = 8
}
for _, start := range openings {
contentStart := start
@@ -629,9 +616,20 @@ func ParseActionBlocks(text string, tools []ToolDef, cfg Config) ([]ToolCall, st
// Filter arguments against the tool's input schema to strip unknown params
if schema, ok := toolSchemaMap[call.Name]; ok && len(schema) > 0 {
call.Arguments = filterArgsBySchema(call.Arguments, schema)
if !hasRequiredArgs(call.Arguments, schema) {
continue
}
}
spans = append(spans, span{start: start, end: end + 3})
key := toolCallKey(call)
if seen[key] {
continue
}
seen[key] = true
if len(calls) >= maxCalls {
continue
}
calls = append(calls, call)
spans = append(spans, span{start: start, end: end + 3})
}
if len(calls) == 0 {
@@ -649,6 +647,11 @@ func ParseActionBlocks(text string, tools []ToolDef, cfg Config) ([]ToolCall, st
return calls, strings.TrimSpace(clean), nil
}
func toolCallKey(call ToolCall) string {
args, _ := json.Marshal(call.Arguments)
return strings.ToLower(strings.TrimSpace(call.Name)) + "\x00" + string(args)
}
func normalizeToolName(raw string, available map[string]string) string {
name := strings.TrimSpace(raw)
if name == "" {
@@ -1011,6 +1014,19 @@ func filterArgsBySchema(args map[string]any, schema map[string]any) map[string]a
return out
}
func hasRequiredArgs(args map[string]any, schema map[string]any) bool {
for _, key := range requiredKeys(schema) {
value, ok := args[key]
if !ok {
return false
}
if s, ok := value.(string); ok && strings.TrimSpace(s) == "" {
return false
}
}
return true
}
func cloneMap(src map[string]any) map[string]any {
if src == nil {
return nil

59
internal/toolemulation/toolemulation_test.go
View File

@@ -86,6 +86,8 @@ func TestInjectToolingIncludesAutoToolGuidance(t *testing.T) {
"Core tool syntax examples",
"conceptual question",
"NEVER ask the user to run a command",
"Emit at most 5 independent tool actions",
"exclude node_modules",
} {
if !strings.Contains(prompt, want) {
t.Fatalf("prompt missing %q:\n%s", want, prompt)
@@ -154,3 +156,60 @@ func TestParseActionBlocksMapsReadAlias(t *testing.T) {
t.Fatalf("calls = %+v", calls)
}
}
func TestParseActionBlocksDropsCallsMissingRequiredArgs(t *testing.T) {
text := "```json action\n{\"tool\":\"Read\",\"parameters\":{\"path\":\"/tmp/a.txt\"}}\n```"
calls, clean, err := ParseActionBlocks(text, []ToolDef{{
Name: "Read",
InputSchema: map[string]any{
"properties": map[string]any{
"file_path": map[string]any{"type": "string"},
},
"required": []any{"file_path"},
},
}}, Config{})
if err != nil {
t.Fatal(err)
}
if len(calls) != 0 {
t.Fatalf("expected no calls, got %+v", calls)
}
if !strings.Contains(clean, "\"path\"") {
t.Fatalf("clean should preserve unparseable action block, got %q", clean)
}
}
func TestParseActionBlocksDeduplicatesAndLimitsCalls(t *testing.T) {
var b strings.Builder
for i := 0; i < 12; i++ {
command := "pwd"
if i%2 == 1 {
command = "ls " + string(rune('a'+i))
}
b.WriteString("```json action\n")
b.WriteString(`{"tool":"Bash","parameters":{"command":"` + command + `"}}`)
b.WriteString("\n```\n")
}
calls, clean, err := ParseActionBlocks(b.String(), []ToolDef{{
Name: "Bash",
InputSchema: map[string]any{
"properties": map[string]any{
"command": map[string]any{"type": "string"},
},
"required": []any{"command"},
},
}}, Config{MaxToolCalls: 3})
if err != nil {
t.Fatal(err)
}
if clean != "" {
t.Fatalf("clean = %q", clean)
}
if len(calls) != 3 {
t.Fatalf("call count = %d, calls = %+v", len(calls), calls)
}
if calls[0].Arguments["command"] != "pwd" {
t.Fatalf("first command = %+v", calls[0].Arguments)
}
}

2
scripts/build.ps1
View File

@@ -1,6 +1,6 @@
param(
[string]$OutputDir = "dist",
[string]$BinaryName = "lingma-ipc-proxy.exe",
[string]$BinaryName = "lingma-proxy.exe",
[switch]$Clean
)

203
scripts/deploy-remote.sh Executable file
View File

@@ -0,0 +1,203 @@
#!/bin/bash
set -euo pipefail
usage() {
cat <<'EOF'
Usage:
REMOTE_HOST=150.158.105.6 \
REMOTE_USER=root \
REMOTE_PASSWORD='your-password' \
./scripts/deploy-remote.sh
Optional environment variables:
REMOTE_PORT=22
REMOTE_DIR=/root/lingma-proxy-compose
REMOTE_BUILD_DIR=/root/lingma-proxy-compose/src
REMOTE_PUBLIC_PORT=13123
REMOTE_CONTAINER_NAME=lingma-proxy-uploaded
REMOTE_IMAGE_NAME=lingma-proxy-uploaded
REMOTE_SESSION_BUNDLE_PATH=/root/lingma-proxy-compose/secrets/lingma-session.b64
LINGMA_REMOTE_BASE_URL=https://lingma.alibabacloud.com
LINGMA_SOURCE_TYPE=vsix
LINGMA_VSIX_URL=https://tongyi-code.oss-cn-hangzhou.aliyuncs.com/vscode/tongyi-lingma-latest.vsix
LINGMA_MARKETPLACE_PUBLISHER=Alibaba-Cloud
LINGMA_MARKETPLACE_EXTENSION=tongyi-lingma
LINGMA_PROXY_MODEL=org_auto
LINGMA_PROXY_API_KEYS=
VERIFY_PUBLIC=false
EOF
}
require_env() {
local name="$1"
if [ -z "${!name:-}" ]; then
echo "Missing required environment variable: $name" >&2
usage >&2
exit 1
fi
}
require_cmd() {
command -v "$1" >/dev/null 2>&1 || {
echo "Required command not found: $1" >&2
exit 1
}
}
if [ "${1:-}" = "--help" ] || [ "${1:-}" = "-h" ]; then
usage
exit 0
fi
require_cmd sshpass
require_cmd ssh
require_cmd scp
require_cmd curl
require_cmd tar
require_env REMOTE_HOST
require_env REMOTE_USER
require_env REMOTE_PASSWORD
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
REMOTE_PORT="${REMOTE_PORT:-22}"
REMOTE_DIR="${REMOTE_DIR:-/root/lingma-proxy-compose}"
REMOTE_BUILD_DIR="${REMOTE_BUILD_DIR:-$REMOTE_DIR/src}"
REMOTE_PUBLIC_PORT="${REMOTE_PUBLIC_PORT:-13123}"
REMOTE_CONTAINER_NAME="${REMOTE_CONTAINER_NAME:-lingma-proxy-uploaded}"
REMOTE_IMAGE_NAME="${REMOTE_IMAGE_NAME:-lingma-proxy-uploaded}"
REMOTE_SESSION_BUNDLE_PATH="${REMOTE_SESSION_BUNDLE_PATH:-$REMOTE_DIR/secrets/lingma-session.b64}"
LINGMA_REMOTE_BASE_URL="${LINGMA_REMOTE_BASE_URL:-https://lingma.alibabacloud.com}"
LINGMA_SOURCE_TYPE="${LINGMA_SOURCE_TYPE:-vsix}"
LINGMA_VSIX_URL="${LINGMA_VSIX_URL:-https://tongyi-code.oss-cn-hangzhou.aliyuncs.com/vscode/tongyi-lingma-latest.vsix}"
LINGMA_MARKETPLACE_PUBLISHER="${LINGMA_MARKETPLACE_PUBLISHER:-Alibaba-Cloud}"
LINGMA_MARKETPLACE_EXTENSION="${LINGMA_MARKETPLACE_EXTENSION:-tongyi-lingma}"
LINGMA_PROXY_MODEL="${LINGMA_PROXY_MODEL:-org_auto}"
LINGMA_PROXY_API_KEYS="${LINGMA_PROXY_API_KEYS:-}"
VERIFY_PUBLIC="${VERIFY_PUBLIC:-false}"
VERIFY_API_KEY="${LINGMA_PROXY_API_KEYS%%,*}"
if [ "$REMOTE_BUILD_DIR" = "$REMOTE_DIR" ]; then
echo "REMOTE_BUILD_DIR must be different from REMOTE_DIR" >&2
exit 1
fi
case "$REMOTE_BUILD_DIR" in
"$REMOTE_DIR"/*) REMOTE_BUILD_CONTEXT_SUBDIR="${REMOTE_BUILD_DIR#"$REMOTE_DIR"/}" ;;
*)
echo "REMOTE_BUILD_DIR must be inside REMOTE_DIR so Docker can access it" >&2
exit 1
;;
esac
if [ ! -d "$REPO_ROOT/vendor" ]; then
echo "Missing vendor/ directory. Run 'go mod vendor' first." >&2
exit 1
fi
SSH_BASE=(sshpass -p "$REMOTE_PASSWORD" ssh -o StrictHostKeyChecking=no -p "$REMOTE_PORT" "$REMOTE_USER@$REMOTE_HOST")
SCP_BASE=(sshpass -p "$REMOTE_PASSWORD" scp -o StrictHostKeyChecking=no -P "$REMOTE_PORT")
work_dir="$(mktemp -d)"
trap 'rm -rf "$work_dir"' EXIT
source_dir="$work_dir/source"
archive_path="$work_dir/source.tar.gz"
dockerfile_path="$work_dir/Dockerfile.uploaded"
env_path="$work_dir/.env.container"
remote_archive_path="$REMOTE_DIR/source.tar.gz"
mkdir -p "$source_dir"
cp -R "$REPO_ROOT/cmd" "$source_dir/cmd"
cp -R "$REPO_ROOT/internal" "$source_dir/internal"
cp -R "$REPO_ROOT/vendor" "$source_dir/vendor"
cp "$REPO_ROOT/go.mod" "$source_dir/go.mod"
cp "$REPO_ROOT/go.sum" "$source_dir/go.sum"
if [ -d "$REPO_ROOT/pkg" ]; then
cp -R "$REPO_ROOT/pkg" "$source_dir/pkg"
fi
tar -C "$source_dir" -czf "$archive_path" .
cat >"$dockerfile_path" <<EOF
FROM golang:1.23.6-bookworm AS builder
WORKDIR /src
COPY $REMOTE_BUILD_CONTEXT_SUBDIR/ /src/
ENV GOTOOLCHAIN=local GOFLAGS=-mod=vendor CGO_ENABLED=0 GOOS=linux GOARCH=amd64
RUN go build -o /out/lingma-proxy ./cmd/lingma-ipc-proxy
FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates wget && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY --from=builder /out/lingma-proxy /usr/local/bin/lingma-proxy
EXPOSE 8095
CMD ["lingma-proxy", "--host", "0.0.0.0", "--port", "8095", "--backend", "remote"]
EOF
cat >"$env_path" <<EOF
LINGMA_REMOTE_BASE_URL=$LINGMA_REMOTE_BASE_URL
LINGMA_REMOTE_AUTH_FILE=
LINGMA_BOOTSTRAP_ENABLED=true
LINGMA_SOURCE_TYPE=$LINGMA_SOURCE_TYPE
LINGMA_VSIX_URL=$LINGMA_VSIX_URL
LINGMA_MARKETPLACE_PUBLISHER=$LINGMA_MARKETPLACE_PUBLISHER
LINGMA_MARKETPLACE_EXTENSION=$LINGMA_MARKETPLACE_EXTENSION
LINGMA_BIN=/app/data/bin/Lingma
LINGMA_BOOTSTRAP_OUTPUT_DIR=/app/data/bin/release
LINGMA_BOOTSTRAP_ALWAYS=true
LINGMA_FORCE_REFRESH=false
LINGMA_WORK_DIR=/app/data/.lingma/vscode/sharedClientCache
LINGMA_SESSION_BUNDLE=
LINGMA_SESSION_BUNDLE_FILE=/secrets/lingma-session.b64
LINGMA_PROXY_BACKEND=remote
LINGMA_PROXY_SESSION_MODE=auto
LINGMA_PROXY_MODEL=$LINGMA_PROXY_MODEL
LINGMA_PROXY_API_KEYS=$LINGMA_PROXY_API_KEYS
LINGMA_PROXY_TIMEOUT_SECONDS=0
LINGMA_REMOTE_FALLBACK_ENABLED=true
EOF
echo "==> Ensuring remote deploy directory exists"
"${SSH_BASE[@]}" "mkdir -p '$REMOTE_DIR' '$REMOTE_DIR/data' '$REMOTE_DIR/secrets' '$REMOTE_BUILD_DIR'"
echo "==> Checking remote build prerequisites"
"${SSH_BASE[@]}" "command -v docker >/dev/null 2>&1 && command -v tar >/dev/null 2>&1 && command -v curl >/dev/null 2>&1"
echo "==> Checking remote session bundle"
"${SSH_BASE[@]}" "test -f '$REMOTE_SESSION_BUNDLE_PATH'"
echo "==> Uploading source bundle and runtime files"
"${SCP_BASE[@]}" "$archive_path" "$REMOTE_USER@$REMOTE_HOST:$remote_archive_path"
"${SCP_BASE[@]}" "$dockerfile_path" "$REMOTE_USER@$REMOTE_HOST:$REMOTE_DIR/Dockerfile.uploaded"
"${SCP_BASE[@]}" "$env_path" "$REMOTE_USER@$REMOTE_HOST:$REMOTE_DIR/.env.container"
echo "==> Preparing remote build context"
"${SSH_BASE[@]}" "rm -rf '$REMOTE_BUILD_DIR' && mkdir -p '$REMOTE_BUILD_DIR' && tar -xzf '$remote_archive_path' -C '$REMOTE_BUILD_DIR'"
echo "==> Rebuilding remote runtime image"
"${SSH_BASE[@]}" "cd '$REMOTE_DIR' && docker build -f Dockerfile.uploaded -t '$REMOTE_IMAGE_NAME' ."
echo "==> Recreating remote container"
"${SSH_BASE[@]}" "cd '$REMOTE_DIR' && docker rm -f '$REMOTE_CONTAINER_NAME' >/dev/null 2>&1 || true && docker run -d --name '$REMOTE_CONTAINER_NAME' --restart unless-stopped --env-file .env.container -p '$REMOTE_PUBLIC_PORT:8095' -v '$REMOTE_DIR/data:/app/data' -v '$REMOTE_DIR/secrets:/secrets:ro' '$REMOTE_IMAGE_NAME' >/dev/null"
echo "==> Waiting for remote health endpoint"
"${SSH_BASE[@]}" 'for i in $(seq 1 24); do curl -fsS "http://127.0.0.1:'"$REMOTE_PUBLIC_PORT"'/runtime/status" && exit 0; sleep 5; done; docker logs --tail 120 '"$REMOTE_CONTAINER_NAME"' >&2; exit 1'
echo
echo "==> Remote models"
if [ -n "$VERIFY_API_KEY" ]; then
"${SSH_BASE[@]}" "curl -fsS -H 'Authorization: Bearer $VERIFY_API_KEY' http://127.0.0.1:$REMOTE_PUBLIC_PORT/v1/models"
else
"${SSH_BASE[@]}" "curl -fsS http://127.0.0.1:$REMOTE_PUBLIC_PORT/v1/models"
fi
if [ "$VERIFY_PUBLIC" = "true" ]; then
echo
echo "==> Public runtime check"
curl -fsS "http://$REMOTE_HOST:$REMOTE_PUBLIC_PORT/runtime/status"
fi
echo
echo "Deploy complete: http://$REMOTE_HOST:$REMOTE_PUBLIC_PORT"

6
scripts/install-nssm-service.ps1
View File

@@ -1,10 +1,10 @@
param(
[string]$ServiceName = "LingmaIpcProxy",
[string]$ServiceName = "LingmaProxy",
[string]$BinaryPath = "",
[string]$Arguments = "--host 127.0.0.1 --port 8095 --session-mode auto",
[string]$WorkingDirectory = "",
[string]$NssmPath = "nssm.exe",
[string]$Description = "Lingma IPC proxy service"
[string]$Description = "Lingma Proxy service"
)
$ErrorActionPreference = "Stop"
@@ -12,7 +12,7 @@ $ErrorActionPreference = "Stop"
$repoRoot = Split-Path -Parent $PSScriptRoot
if ([string]::IsNullOrWhiteSpace($BinaryPath)) {
$BinaryPath = Join-Path $repoRoot "dist\lingma-ipc-proxy.exe"
$BinaryPath = Join-Path $repoRoot "dist\lingma-proxy.exe"
}
if ([string]::IsNullOrWhiteSpace($WorkingDirectory)) {
$WorkingDirectory = $repoRoot

8
scripts/install-winsw-service.ps1
View File

@@ -1,5 +1,5 @@
param(
[string]$ServiceName = "LingmaIpcProxy",
[string]$ServiceName = "LingmaProxy",
[string]$BinaryPath = "",
[string]$Arguments = "--host 127.0.0.1 --port 8095 --session-mode auto",
[string]$WorkingDirectory = "",
@@ -12,7 +12,7 @@ $ErrorActionPreference = "Stop"
$repoRoot = Split-Path -Parent $PSScriptRoot
if ([string]::IsNullOrWhiteSpace($BinaryPath)) {
$BinaryPath = Join-Path $repoRoot "dist\lingma-ipc-proxy.exe"
$BinaryPath = Join-Path $repoRoot "dist\lingma-proxy.exe"
}
if ([string]::IsNullOrWhiteSpace($WorkingDirectory)) {
$WorkingDirectory = $repoRoot
@@ -21,7 +21,7 @@ if ([string]::IsNullOrWhiteSpace($WinSWExePath)) {
$WinSWExePath = Join-Path $repoRoot "dist\WinSW-x64.exe"
}
if ([string]::IsNullOrWhiteSpace($TemplatePath)) {
$TemplatePath = Join-Path $PSScriptRoot "lingma-ipc-proxy.xml.template"
$TemplatePath = Join-Path $PSScriptRoot "lingma-proxy.xml.template"
}
if (!(Test-Path $BinaryPath)) {
@@ -40,7 +40,7 @@ $serviceXmlPath = Join-Path $repoRoot "$ServiceName.xml"
$xml = Get-Content -Raw $TemplatePath
$xml = $xml.Replace("__SERVICE_ID__", $ServiceName)
$xml = $xml.Replace("__SERVICE_NAME__", $ServiceName)
$xml = $xml.Replace("__SERVICE_DESCRIPTION__", "Lingma IPC proxy service")
$xml = $xml.Replace("__SERVICE_DESCRIPTION__", "Lingma Proxy service")
$xml = $xml.Replace("__EXECUTABLE__", $BinaryPath)
$xml = $xml.Replace("__ARGUMENTS__", $Arguments)
$xml = $xml.Replace("__WORKDIR__", $WorkingDirectory)

0
scripts/lingma-ipc-proxy.xml.template → scripts/lingma-proxy.xml.template
View File

4
scripts/test-macos.sh
View File

@@ -1,5 +1,5 @@
#!/bin/bash
# lingma-ipc-proxy macOS 功能测试脚本
# Lingma Proxy macOS 功能测试脚本
# 用法: ./scripts/test-macos.sh [host:port]
ENDPOINT="${1:-127.0.0.1:8095}"
@@ -23,7 +23,7 @@ assert_contains() {
}
echo "========================================"
echo "lingma-ipc-proxy macOS 功能测试"
echo "Lingma Proxy macOS 功能测试"
echo "端点: http://$ENDPOINT"
echo "========================================"

1
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
*.exe

244
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/ARCHITECTURE.md vendored Normal file
View File

@@ -0,0 +1,244 @@
# Architecture
This document will attempt to explain how this code works.
## Windows COM
Windows makes heavy use of it's [COM api](https://en.wikipedia.org/wiki/Component_Object_Model),
(Component Object Model) which is a binary interface - allowing programs that agree on a memory
layout in order to communicate.
COM apis are typically Object Oriented, and based on interfaces. This should be familiar to Go
programmers, since Go includes interfaces as a core part of its language design and type system.
The difference being that in COM we don't get any runtime help, nice syntax or type safety. We
get raw [VTables](https://en.wikipedia.org/wiki/Virtual_method_table) and deal with raw memory.
You can think of COM as like working with a Go api that uses `any` (empty interface) _everywhere_
and typeswitching is required to access methods `file, ok := obj.(File)`.
Some languages like C++ have extensions that support COM and provide convenient wrappers for
generating and using COM apis. Go does not. C also, does not.
However there is a package `go-ole` that allows us to _call_ COM apis with some level of
convenience - which we will use where possible. What go-ole does not expose is a way to
implement a COM object in Go.
## Interacting with COM objects in pure Go
In order to interact with COM objects we need to:
1. locate headers containing the VTable definitions
2. define vtables in Go that are compatable with those definitions
3. invoke the appropriate COM objects using our vtables and the syscall package
### 1. locate headers
Download Windows SDK via the [Visual Studio installer](https://visualstudio.microsoft.com/downloads).
You will need to check "Desktop development with C++".
Once complete you can navigate to the SDK include directory.
In our case we needed `Windows.ui.notifications.h`, which contains the definitions of
the types we want to call, and `NotificationActivationCallback.h` which contains the definition of
`INotificationActivationCallback` which is the interface we need to _implement_.
### 2. define vtables in Go
The VTables are defined in C (mired in macros). We need to define compatible vtables in Go syntax
so we can call the ones defined in the header.
COM objects are structured in a such a way that we want a parent struct who's first field is a pointer
to the vtable struct. A full example is provided later, for now it we need something like this:
```go
type Object struct {
lpvtbl *ObjectVtbl
}
type ObjectVtbl struct {
MethodOne uintptr
MethdoTwo uintptr
//...
}
```
### 3. invoke methods in Go
Using package `syscall` we can invoke these methods (provided the uintptr are valid) using
`syscal.SyscallN`. Paramters and return values are defined in the C headers.
```go
func (v *Object) One() error {
hr, _, _ := syscall.SyscallN(uintptr(v))
if hr != ole.S_OK {
return ole.NewError(hr)
}
return nil
}
```
With that we can inoke methods on a COM object. This is how `go-ole` works.
## Implementing a COM object in pure Go (no cgo!)
To do this we will need to allocate raw memory for the VTables (so that Go garbage collector
doesn't interfere) and write our function pointers to the VTables.
Since these are not safe Go capabilities we will need the help of package `syscall` (on Windows).
Package `syscall` provides two very important functions:
1. `NewProc` - which loads a function from a DLL
2. `NewCallback` - which allocates a C-callable function pointer from a Go function
For the first part, we can load the Windows kernel api via `kernel32.dll` system dll, and
pull out `GlobalAlloc` and `GlobalFree` using `syscall.NewProc`.
For the second part, we can use `syscall.NewCallback` to build a C-callable function pointer
from a Go function and instantiate the VtTables with it. Caveat emptor: memory allocated by
`NewCallback` is never released, and only 1024 callbacks are guaranteed to be allowed. This
is why we only allocate the callbacks once on init.
Thus we can implement a COM object (invokable from C) like this:
```go
// Initialize our kernel functions.
var (
kernel32 = windows.NewLazySystemDLL("kernel32.dll")
procMalloc = kernel32.NewProc("GlobalAlloc")
procFree = kernel32.NewProc("GlobalFree")
)
// malloc allocates raw memory using the Windows kernel.
// In case of out of memory, the returned pointer will be nil.
// The memory is zeroed out to make sure we don't get garbage that looks like
// valid Go data types.
func malloc(size uintptr) unsafe.Pointer {
hr, _, _ := procMalloc.Call(uintptr(GMEM_FIXED|GMEM_ZEROINIT), uintptr(size))
if hr == 0 {
return nil
}
return unsafe.Pointer(hr)
}
// free deallocates raw memory allocated by malloc.
func free(object unsafe.Pointer) {
procFree.Call(uintptr(object))
}
// Object defines our object.
// This is how COM objects are laid out in memory, where the first field is a pointer
// to a vtable, and the vtable's fields are pointers to functions.
type Object struct {
lpvtbl *ObjectVtbl // lpvtbl is a COM conventional name for this field.
}
// ObjectVtbl defines the Vtable of our object.
type ObjectVtbl struct {
MethodOne uintptr
MethodTwo uintptr
MethodThree uintptr
}
// These methods are allocated once as package globals because Go will never reclaim the
// memory allocated for such callbacks.
//
// All arguments must be uintptr sized, and the return must be a uintptr as well.
//
// By convention, the first parameter is a pointer to the parent object.
var (
methodOne = syscall.NewCallback(func(this *Object) uintptr {
fmt.Printf("methodOne invoked\n")
return uintptr(0)
})
methodTwo = syscall.NewCallback(func(this *Object) uintptr {
fmt.Printf("methodTwo invoked\n")
return uintptr(0)
})
methodThree = syscall.NewCallback(func(this *Object) uintptr {
fmt.Printf("methodThree invoked\n")
return uintptr(0)
})
)
func NewObject() *Object {
// Allocate the parent object and the vtable.
obj := (*Object)(malloc(unsafe.Sizeof(Object{})))
vtbl := (*ObjectVtbl)(malloc(unsafe.Sizeof(ObjectVtbl{})))
// Initialize the vtable with our static callback implementations.
vtbl.MethodOne = methodOne
vtbl.MethodTwo = methodTwo
vtbl.MethodThree = methodThree
// The returned object must be freed by GlobalFree.
object.lpvtbl = vtbl
return obj
}
```
## WinRT and Toast Notifications
For this package the vtables we need are located in various headers `Windows.ui.notifications.h` and
`NotificationActivationCallback.h` and `combase.h`.
With all of the vtables replicated in Go as explained above we now need to interact with the Windows
Runtime.
First we need to initialize the Windows Runtime with `RoInitialize`.
```go
ole.RoInitialize(0)
```
Traditional COM uses GUIDs to identify objects and interfaces. WinRT uses strings (mapped to GUIDS
at runtime).
To instantiate a WinRT COM object we invoke `RoGetActivationFactory` with the class string along with
the interface GUID we expect to use.
```go
CLSID_ToastNotification := "Windows.UI.Notifications.ToastNotification"
IID_IToastNotificationFactory := ole.NewGUID("{50AC103F-D235-4598-BBEF-98FE4D1A3AD4}")
factoryObject, err := ole.RoGetActivationFactory(CLSID_ToastNotification, IID_ToastNotificationFactory)
if err != nil {
return nil, fmt.Errorf("getting activation factory: %w", err)
}
```
From there we can unsafe cast to our callback definition (ole doesn't provide direct access to the methods).
```go
factory := (*IToastNotificationFactory)(unsafe.Pointer(factoryObject))
notification, err := factory.CreateToastNotification(xml)
```
Repeat this process per object we need to instantiate.
To generate a toast notification from XML with a callback we need to instantiate several COM objects:
1. `INotificationActivationCallback` our implementation to be invoked by the runtime
1. `ClassFactory` which can instantiate our `INotificationActivationCallback` implementation
1. `XmlDocument` to contain the xml content of the notification
1. `XmlDocumentIO` to provide an IO interface to the xml document (so we can write the xml to it)
1. `Notification` specifying the content of the notification
1. `Notifier` for showing notifications
Finally we register our class factory using `CoRegisterClassObject` so the runtime can call us back
and then we invoke `Notifier.Show` passing in the `Notification` object to display the notification.
In addition to calling and implementing COM objects we need to manipulate registry state to tell the
Windows Runtime metadata about our application.
1. register a CLSID (GUID) for our INotificationActivationCallback; this is how the runtime knows
what object to ask for
2. optionally provide an icon and an activation executable to be invoked when our application is not running
With all of that correctly configured we can generate toast notifications on Windows in pure Go!

61
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/LICENSE vendored Normal file
View File

@@ -0,0 +1,61 @@
This project is dual-licensed under the UNLICENSE or
the MIT license with the SPDX identifier:
SPDX-License-Identifier: Unlicense OR MIT
You may use the project under the terms of either license.
Both licenses are reproduced below.
----
The MIT License (MIT)
Copyright (c) 2023 Jack Mordaunt
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
---
---
The UNLICENSE
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.
In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
For more information, please refer to <https://unlicense.org/>
---

86
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/README.md vendored Normal file
View File

@@ -0,0 +1,86 @@
# go-toast
This package implements Windows toast notifications using the Windows Runtime COM API.
The XML schema used to describe such notifications is here:
https://learn.microsoft.com/en-us/windows/apps/design/shell/tiles-and-notifications/adaptive-interactive-toasts
Package `wintoast` offers a lower-level api.
Package `toast` offers a higher-level wrapper.
`wintoast` uses build tags to guard Windows only code. It will still compile on
non-Windows platforms, however the functions are stubbed out and will do nothing
when invoked.
## Usage
### Basic
```go
noti := toast.Notification{
AppID: "My cool app",
Title: "Title",
Body: "Body",
}
err := noti.Push()
```
### Actions / Inputs with Callback
Additionally, we can respond to notification activation with a callback.
```go
// Set the callback that receives the data from the notification.
// Any data from actions or inputs will be accessible here.
toast.SetActivationCallback(func(args string, data []UserData) {
fmt.Printf("args: %q, data: %v\n", args, data)
})
n := toast.Notification{
AppID: "My cool app",
Title: "Title",
Body: "Body",
}
n.Inputs = append(n.Inputs, toast.Input{
ID: "reply-to:john-doe",
Title: "Reply",
Placeholder: "Reply to John Doe",
})
n.Inputs = append(n.Inputs, toast.Input{
ID: "select-action",
Title: "Selection Action",
Placeholder: "Pick an action to perform",
Selections: []toast.InputSelection{
{
ID: "1",
Content: "do thing one",
},
{
ID: "2",
Content: "do thing two",
},
{
ID: "3",
Content: "do thing three",
},
},
})
n.Actions = append(n.Actions, toast.Action{
Type: toast.Foreground,
Content: "Send",
Arguments: "send",
})
n.Actions = append(n.Actions, toast.Action{
Type: toast.Foreground,
Content: "Close",
Arguments: "close",
})
err := n.Push()
```

65
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/constants.go vendored Normal file
View File

@@ -0,0 +1,65 @@
package toast
import "errors"
var (
ErrorInvalidAudio error = errors.New("toast: invalid audio")
ErrorInvalidDuration = errors.New("toast: invalid duration")
)
// toastAudio identifies audio that Windows can play.
type toastAudio = string
const (
Default toastAudio = "ms-winsoundevent:Notification.Default"
IM toastAudio = "ms-winsoundevent:Notification.IM"
Mail toastAudio = "ms-winsoundevent:Notification.Mail"
Reminder toastAudio = "ms-winsoundevent:Notification.Reminder"
SMS toastAudio = "ms-winsoundevent:Notification.SMS"
LoopingAlarm toastAudio = "ms-winsoundevent:Notification.Looping.Alarm"
LoopingAlarm2 toastAudio = "ms-winsoundevent:Notification.Looping.Alarm2"
LoopingAlarm3 toastAudio = "ms-winsoundevent:Notification.Looping.Alarm3"
LoopingAlarm4 toastAudio = "ms-winsoundevent:Notification.Looping.Alarm4"
LoopingAlarm5 toastAudio = "ms-winsoundevent:Notification.Looping.Alarm5"
LoopingAlarm6 toastAudio = "ms-winsoundevent:Notification.Looping.Alarm6"
LoopingAlarm7 toastAudio = "ms-winsoundevent:Notification.Looping.Alarm7"
LoopingAlarm8 toastAudio = "ms-winsoundevent:Notification.Looping.Alarm8"
LoopingAlarm9 toastAudio = "ms-winsoundevent:Notification.Looping.Alarm9"
LoopingAlarm10 toastAudio = "ms-winsoundevent:Notification.Looping.Alarm10"
LoopingCall toastAudio = "ms-winsoundevent:Notification.Looping.Call"
LoopingCall2 toastAudio = "ms-winsoundevent:Notification.Looping.Call2"
LoopingCall3 toastAudio = "ms-winsoundevent:Notification.Looping.Call3"
LoopingCall4 toastAudio = "ms-winsoundevent:Notification.Looping.Call4"
LoopingCall5 toastAudio = "ms-winsoundevent:Notification.Looping.Call5"
LoopingCall6 toastAudio = "ms-winsoundevent:Notification.Looping.Call6"
LoopingCall7 toastAudio = "ms-winsoundevent:Notification.Looping.Call7"
LoopingCall8 toastAudio = "ms-winsoundevent:Notification.Looping.Call8"
LoopingCall9 toastAudio = "ms-winsoundevent:Notification.Looping.Call9"
LoopingCall10 toastAudio = "ms-winsoundevent:Notification.Looping.Call10"
Silent toastAudio = "silent"
)
// toastduration identifies toast duration for audio playback.
type toastDuration = string
const (
Short toastDuration = "short"
Long toastDuration = "long"
)
// ActivationType identifies the method that Windows Runtime will use to handle
// notification interactions.
//
// See https://learn.microsoft.com/en-us/dotnet/api/microsoft.toolkit.uwp.notifications.toastactivationtype
type ActivationType = string
const (
// Protocol is for launching third-party applications using a protocol uri, like https or mailto.
Protocol ActivationType = "protocol"
// Foreground is for launching your foreground application. This is required to enable the activation
// callback. There is a third option: Background, however for Desktop applications Foreground and
// Background behave identically.
//
// See https://learn.microsoft.com/en-us/windows/apps/design/shell/tiles-and-notifications/send-local-toast-desktop-cpp-wrl#foreground-vs-background-activation
Foreground ActivationType = "foreground"
)

73
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/internal/winrt/data/xml/dom/xmldocument.go vendored Normal file
View File

@@ -0,0 +1,73 @@
// Code generated by winrt-go-gen. DO NOT EDIT.
//go:build windows
//nolint:all
package dom
import (
"syscall"
"unsafe"
"github.com/go-ole/go-ole"
)
const SignatureXmlDocument string = "rc(Windows.Data.Xml.Dom.XmlDocument;{f7f3a506-1e87-42d6-bcfb-b8c809fa5494})"
type XmlDocument struct {
ole.IUnknown
}
func NewXmlDocument() (*XmlDocument, error) {
inspectable, err := ole.RoActivateInstance("Windows.Data.Xml.Dom.XmlDocument")
if err != nil {
return nil, err
}
return (*XmlDocument)(unsafe.Pointer(inspectable)), nil
}
func (impl *XmlDocument) LoadXml(xml string) error {
itf := impl.MustQueryInterface(ole.NewGUID(GUIDiXmlDocumentIO))
defer itf.Release()
v := (*iXmlDocumentIO)(unsafe.Pointer(itf))
return v.LoadXml(xml)
}
const (
GUIDiXmlDocumentIO string = "6cd0e74e-ee65-4489-9ebf-ca43e87ba637"
SignatureiXmlDocumentIO string = "{6cd0e74e-ee65-4489-9ebf-ca43e87ba637}"
)
type iXmlDocumentIO struct {
ole.IInspectable
}
type iXmlDocumentIOVtbl struct {
ole.IInspectableVtbl
LoadXml uintptr
LoadXmlWithSettings uintptr
SaveToFileAsync uintptr
}
func (v *iXmlDocumentIO) VTable() *iXmlDocumentIOVtbl {
return (*iXmlDocumentIOVtbl)(unsafe.Pointer(v.RawVTable))
}
func (v *iXmlDocumentIO) LoadXml(xml string) error {
xmlHStr, err := ole.NewHString(xml)
if err != nil {
return err
}
hr, _, _ := syscall.SyscallN(
v.VTable().LoadXml,
uintptr(unsafe.Pointer(v)), // this
uintptr(xmlHStr), // in string
)
if hr != 0 {
return ole.NewError(hr)
}
return nil
}

88
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/internal/winrt/ui/notifications/toastnotification.go vendored Normal file
View File

@@ -0,0 +1,88 @@
// Code generated by winrt-go-gen. DO NOT EDIT.
//go:build windows
//nolint:all
package notifications
import (
"syscall"
"unsafe"
"git.sr.ht/~jackmordaunt/go-toast/v2/internal/winrt/data/xml/dom"
"github.com/go-ole/go-ole"
)
const SignatureToastNotification string = "rc(Windows.UI.Notifications.ToastNotification;{997e2675-059e-4e60-8b06-1760917c8b80})"
func CreateToastNotification(content *dom.XmlDocument) (*ToastNotification, error) {
inspectable, err := ole.RoGetActivationFactory("Windows.UI.Notifications.ToastNotification", ole.NewGUID(GUIDiToastNotificationFactory))
if err != nil {
return nil, err
}
v := (*iToastNotificationFactory)(unsafe.Pointer(inspectable))
var out *ToastNotification
hr, _, _ := syscall.SyscallN(
v.VTable().CreateToastNotification,
0, // this is a static func, so there's no this
uintptr(unsafe.Pointer(content)), // in dom.XmlDocument
uintptr(unsafe.Pointer(&out)), // out ToastNotification
)
if hr != 0 {
return nil, ole.NewError(hr)
}
return out, nil
}
type ToastNotification struct {
ole.IUnknown
}
const (
GUIDiToastNotification string = "997e2675-059e-4e60-8b06-1760917c8b80"
SignatureiToastNotification string = "{997e2675-059e-4e60-8b06-1760917c8b80}"
)
type iToastNotification struct {
ole.IInspectable
}
type iToastNotificationVtbl struct {
ole.IInspectableVtbl
GetContent uintptr
SetExpirationTime uintptr
GetExpirationTime uintptr
AddDismissed uintptr
RemoveDismissed uintptr
AddActivated uintptr
RemoveActivated uintptr
AddFailed uintptr
RemoveFailed uintptr
}
func (v *iToastNotification) VTable() *iToastNotificationVtbl {
return (*iToastNotificationVtbl)(unsafe.Pointer(v.RawVTable))
}
const (
GUIDiToastNotificationFactory string = "04124b20-82c6-4229-b109-fd9ed4662b53"
SignatureiToastNotificationFactory string = "{04124b20-82c6-4229-b109-fd9ed4662b53}"
)
type iToastNotificationFactory struct {
ole.IInspectable
}
type iToastNotificationFactoryVtbl struct {
ole.IInspectableVtbl
CreateToastNotification uintptr
}
func (v *iToastNotificationFactory) VTable() *iToastNotificationFactoryVtbl {
return (*iToastNotificationFactoryVtbl)(unsafe.Pointer(v.RawVTable))
}

53
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/internal/winrt/ui/notifications/toastnotificationmanager.go vendored Normal file
View File

@@ -0,0 +1,53 @@
// Code generated by winrt-go-gen. DO NOT EDIT.
//go:build windows
//nolint:all
package notifications
import (
"syscall"
"unsafe"
"github.com/go-ole/go-ole"
)
const (
GUIDiToastNotificationManagerStatics5 string = "d6f5f569-d40d-407c-8989-88cab42cfd14"
SignatureiToastNotificationManagerStatics5 string = "{d6f5f569-d40d-407c-8989-88cab42cfd14}"
)
type iToastNotificationManagerStatics5 struct {
ole.IInspectable
}
type iToastNotificationManagerStatics5Vtbl struct {
ole.IInspectableVtbl
GetDefault uintptr
}
func (v *iToastNotificationManagerStatics5) VTable() *iToastNotificationManagerStatics5Vtbl {
return (*iToastNotificationManagerStatics5Vtbl)(unsafe.Pointer(v.RawVTable))
}
func GetDefault() (*ToastNotificationManagerForUser, error) {
inspectable, err := ole.RoGetActivationFactory("Windows.UI.Notifications.ToastNotificationManager", ole.NewGUID(GUIDiToastNotificationManagerStatics5))
if err != nil {
return nil, err
}
v := (*iToastNotificationManagerStatics5)(unsafe.Pointer(inspectable))
var out *ToastNotificationManagerForUser
hr, _, _ := syscall.SyscallN(
v.VTable().GetDefault,
0, // this is a static func, so there's no this
uintptr(unsafe.Pointer(&out)), // out ToastNotificationManagerForUser
)
if hr != 0 {
return nil, ole.NewError(hr)
}
return out, nil
}

68
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/internal/winrt/ui/notifications/toastnotificationmanagerforuser.go vendored Normal file
View File

@@ -0,0 +1,68 @@
// Code generated by winrt-go-gen. DO NOT EDIT.
//go:build windows
//nolint:all
package notifications
import (
"syscall"
"unsafe"
"github.com/go-ole/go-ole"
)
const SignatureToastNotificationManagerForUser string = "rc(Windows.UI.Notifications.ToastNotificationManagerForUser;{79ab57f6-43fe-487b-8a7f-99567200ae94})"
type ToastNotificationManagerForUser struct {
ole.IUnknown
}
func (impl *ToastNotificationManagerForUser) CreateToastNotifierWithId(applicationId string) (*ToastNotifier, error) {
itf := impl.MustQueryInterface(ole.NewGUID(GUIDiToastNotificationManagerForUser))
defer itf.Release()
v := (*iToastNotificationManagerForUser)(unsafe.Pointer(itf))
return v.CreateToastNotifierWithId(applicationId)
}
const (
GUIDiToastNotificationManagerForUser string = "79ab57f6-43fe-487b-8a7f-99567200ae94"
SignatureiToastNotificationManagerForUser string = "{79ab57f6-43fe-487b-8a7f-99567200ae94}"
)
type iToastNotificationManagerForUser struct {
ole.IInspectable
}
type iToastNotificationManagerForUserVtbl struct {
ole.IInspectableVtbl
CreateToastNotifier uintptr
CreateToastNotifierWithId uintptr
GetHistory uintptr
GetUser uintptr
}
func (v *iToastNotificationManagerForUser) VTable() *iToastNotificationManagerForUserVtbl {
return (*iToastNotificationManagerForUserVtbl)(unsafe.Pointer(v.RawVTable))
}
func (v *iToastNotificationManagerForUser) CreateToastNotifierWithId(applicationId string) (*ToastNotifier, error) {
var out *ToastNotifier
applicationIdHStr, err := ole.NewHString(applicationId)
if err != nil {
return nil, err
}
hr, _, _ := syscall.SyscallN(
v.VTable().CreateToastNotifierWithId,
uintptr(unsafe.Pointer(v)), // this
uintptr(applicationIdHStr), // in string
uintptr(unsafe.Pointer(&out)), // out ToastNotifier
)
if hr != 0 {
return nil, ole.NewError(hr)
}
return out, nil
}

64
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/internal/winrt/ui/notifications/toastnotifier.go vendored Normal file
View File

@@ -0,0 +1,64 @@
// Code generated by winrt-go-gen. DO NOT EDIT.
//go:build windows
//nolint:all
package notifications
import (
"syscall"
"unsafe"
"github.com/go-ole/go-ole"
)
const SignatureToastNotifier string = "rc(Windows.UI.Notifications.ToastNotifier;{75927b93-03f3-41ec-91d3-6e5bac1b38e7})"
type ToastNotifier struct {
ole.IUnknown
}
func (impl *ToastNotifier) Show(notification *ToastNotification) error {
itf := impl.MustQueryInterface(ole.NewGUID(GUIDiToastNotifier))
defer itf.Release()
v := (*iToastNotifier)(unsafe.Pointer(itf))
return v.Show(notification)
}
const (
GUIDiToastNotifier string = "75927b93-03f3-41ec-91d3-6e5bac1b38e7"
SignatureiToastNotifier string = "{75927b93-03f3-41ec-91d3-6e5bac1b38e7}"
)
type iToastNotifier struct {
ole.IInspectable
}
type iToastNotifierVtbl struct {
ole.IInspectableVtbl
Show uintptr
Hide uintptr
GetSetting uintptr
AddToSchedule uintptr
RemoveFromSchedule uintptr
GetScheduledToastNotifications uintptr
}
func (v *iToastNotifier) VTable() *iToastNotifierVtbl {
return (*iToastNotifierVtbl)(unsafe.Pointer(v.RawVTable))
}
func (v *iToastNotifier) Show(notification *ToastNotification) error {
hr, _, _ := syscall.SyscallN(
v.VTable().Show,
uintptr(unsafe.Pointer(v)), // this
uintptr(unsafe.Pointer(notification)), // in ToastNotification
)
if hr != 0 {
return ole.NewError(hr)
}
return nil
}

14
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/tmpl/powershell.go.tmpl vendored Normal file
View File

@@ -0,0 +1,14 @@
[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
[Windows.UI.Notifications.ToastNotification, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null
$APP_ID = '{{if .AppID}}{{.AppID}}{{else}}Windows App{{end}}'
$template = @"
{{.XML}}
"@
$xml = New-Object Windows.Data.Xml.Dom.XmlDocument
$xml.LoadXml($template)
$toast = New-Object Windows.UI.Notifications.ToastNotification $xml
[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier($APP_ID).Show($toast)

28
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/tmpl/tmpl.go vendored Normal file
View File

@@ -0,0 +1,28 @@
// Package tmpl wraps several templates that are used to generate notifications.
//
// The primary template describes the XML structure that the Windows Runtime expects
// to consume. The powershell template describes a script that we can use to execute
// the notification if the Windows Runtime is unavailable.
//
// For more information about the xml schema:
// https://learn.microsoft.com/en-us/uwp/schemas/tiles/toastschema/schema-root
package tmpl
import (
_ "embed"
"text/template"
)
//go:embed xml.go.tmpl
var xml string
//go:embed powershell.go.tmpl
var powershell string
// XMLTemplate describes the XML content that the Windows Runtime uses to build
// toast notifications.
var XMLTemplate = template.Must(template.New("toast-xml").Parse(xml))
// ScriptTemplate describes the Powershell script that will invoke a toast notification
// given some XML.
var ScriptTemplate = template.Must(template.New("script").Parse(powershell))

38
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/tmpl/xml.go.tmpl vendored Normal file
View File

@@ -0,0 +1,38 @@
<?xml version="1.0" encoding="UTF-8"?>
<toast activationType="{{.ActivationType}}" launch="{{.ActivationArguments}}" duration="{{.Duration}}">
<visual>
<binding template="ToastGeneric">
{{if .HeroIcon}}
<image placement="hero" src="{{.HeroIcon}}" />
{{end}}
{{if .Icon}}
<image placement="appLogoOverride" src="{{.Icon}}" {{if .IconCrop}} hint-crop="{{.IconCrop}}" {{end}} />
{{end}}
{{if .Title}}
<text hint-maxLines="1"><![CDATA[{{.Title}}]]></text>
{{end}}
{{if .Body}}
<text><![CDATA[{{.Body}}]]></text>
{{end}}
</binding>
</visual>
{{if ne .Audio "silent"}}
<audio src="{{.Audio}}" loop="{{.Loop}}" />
{{else}}
<audio silent="true" />
{{end}}
{{if .Actions}}
<actions>
{{range .Inputs}}
<input id="{{.ID}}" title="{{.Title}}" placeHolderContent="{{.Placeholder}}" {{if .Selections}} type="selection" {{else}} type="text" {{end}}>
{{range .Selections}}
<selection id="{{.ID}}" content="{{.Content}}" />
{{end}}
</input>
{{end}}
{{range .Actions}}
<action activationType="{{.Type}}" content="{{.Content}}" arguments="{{.Arguments}}" {{if .InputID}} hint-inputId="{{.InputID}}" {{end}} />
{{end}}
</actions>
{{end}}
</toast>

233
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/toast.go vendored Normal file
View File

@@ -0,0 +1,233 @@
// Package toast wraps the lower-level wintoast api and provides an easy way
// to send and respond to toast notifications on Windows.
//
// First, setup your AppData vis SetAppData function. This will install your
// application metadata into the Windows Registry.
//
// Then, if you want in-process callback to be invoked upon user interaction,
// invoke SetActivationCallback.
//
// Finally, generate your notification by instantiation a toast.Notification
// and pushing it with Push method.
package toast
import (
"bytes"
"git.sr.ht/~jackmordaunt/go-toast/v2/tmpl"
"git.sr.ht/~jackmordaunt/go-toast/v2/wintoast"
)
// Notification
//
// The toast notification data. The following fields are strongly recommended;
// - AppID
// - Title
//
// If no toastAudio is provided, then the toast notification will be silent.
//
// The AppID is shown beneath the toast message (in certain cases), and above the notification within the Action
// Center - and is used to group your notifications together. It is recommended that you provide a "pretty"
// name for your app, and not something like "com.example.MyApp". It can be ellided if the value has already
// been set via SetAppData.
//
// If no Title is provided, but a Body is, the body will display as the toast notification's title -
// which is a slightly different font style (heavier).
//
// The Icon should be an absolute path to the icon (as the toast is invoked from a temporary path on the user's
// system, not the working directory).
//
// If you would like the toast to call an external process/open a webpage, then you can set ActivationArguments
// to the uri you would like to trigger when the toast is clicked. For example: "https://google.com" would open
// the Google homepage when the user clicks the toast notification.
// By default, clicking the toast just hides/dismisses it.
//
// The following would show a notification to the user letting them know they received an email, and opens
// gmail.com when they click the notification. It also makes the Windows 10 "mail" sound effect.
//
// toast := toast.Notification{
// AppID: "Google Mail",
// Title: email.Subject,
// Message: email.Preview,
// Icon: "C:/Program Files/Google Mail/icons/logo.png",
// ActivationArguments: "https://gmail.com",
// Audio: toast.Mail,
// }
//
// err := toast.Push()
type Notification struct {
// The name of your app. This value shows up in Windows Action Centre, so make it
// something readable for your users.
AppID string
// The main title/heading for the toast notification.
Title string
// The single/multi line message to display for the toast notification.
Body string
// An optional path to an image on the OS to display to the left of the title & message.
Icon string
// An optional crop style for the Icon.
IconCrop CropStyle
// An optional path to an image to display as a bold hero image.
HeroIcon string
// A color to show as the icon background.
IconBackgroundColor string
// Action to take when the notification is as a whole activated.
ActivationType ActivationType
// The activation/action arguments (invoked when the user clicks the notification).
// This is returned to the callback when activated.
ActivationArguments string
// Optional text input to display before the actions.
Inputs []Input
// Optional action buttons to display below the notification title & message.
Actions []Action
// The audio to play when displaying the toast
Audio toastAudio
// Whether to loop the audio (default false).
Loop bool
// How long the toast should show up for (short/long).
Duration toastDuration
// This is an absolute path to an executable that will launched by the
// Windows Runtime when the COM server is not running. This executable must be able
// to handle the -Embedding flag that Windows invokes it with.
ActivationExe string
}
// CropStyle specifies the hint-crop attribute for an image.
type CropStyle = string
const (
CropStyleEmpty CropStyle = ""
CropStyleSquare CropStyle = "square"
CropStyleCircle CropStyle = "circle"
)
// UserData contains user supplied data from the notification, such as text input
// or a selection.
type UserData = wintoast.UserData
// Input
//
// Defines an input element, generally a text input.
// See https://learn.microsoft.com/en-us/uwp/schemas/tiles/toastschema/element-input for more info.
//
// Inputs are by default textual, however if selections are supplied the input will be rendered
// as a select input.
type Input struct {
ID string
Title string
Placeholder string
Selections []InputSelection
}
// InputSelection
//
// Defines an input selection for use with select inputs.
// See https://learn.microsoft.com/en-us/uwp/schemas/tiles/toastschema/element-selection for more info.
type InputSelection struct {
ID string
Content string
}
// Action
//
// Defines an actionable button.
// See https://msdn.microsoft.com/en-us/windows/uwp/controls-and-patterns/tiles-and-notifications-adaptive-interactive-toasts for more info.
//
// toast.Action{toast.Protocol, "Open Maps", "bingmaps:?q=sushi"}
//
// TODO(jfm): we can likely support an activation callback directly in the Action.
type Action struct {
Type ActivationType
Content string
Arguments string
InputID string // optional ID of any related input, affects styling.
}
// Push the notification to the Windows Runtime via the COM API.
// Ensure [SetAppData] has been called prior to pushing notifications.
//
// notification := toast.Notification{
// AppID: "Example App",
// Title: "My notification",
// Message: "Some message about how important something is...",
// Icon: "go.png",
// Actions: []toast.Action{
// {"protocol", "I'm a button", ""},
// {"protocol", "Me too!", ""},
// },
// }
// err := notification.Push()
// if err != nil {
// log.Fatalln(err)
// }
func (n *Notification) Push() error {
n.applyDefaults()
xml, err := n.buildXML()
if err != nil {
return err
}
return wintoast.Push(n.AppID, xml, wintoast.PowershellFallback)
}
func (n *Notification) applyDefaults() {
if n.ActivationType == "" {
n.ActivationType = Foreground
}
if n.Duration == "" {
n.Duration = Short
}
if n.Audio == "" {
n.Audio = Default
}
}
func (n *Notification) buildXML() (string, error) {
var out bytes.Buffer
err := tmpl.XMLTemplate.Execute(&out, n)
if err != nil {
return "", err
}
return out.String(), nil
}
// SetActivationCallback sets the global activation callback.
//
// The first argument contains application defined data (embedded within the xml),
// which is how the callback knows which part of the toast was activated.
// Argument data is defined by `toast.Action.Arguments` on the notification.
//
// The second argument contains user defined data (input/selected by user).
// All elements of user input will be supplied here, even if the value is empty.
// User inputs correspond to all `toast.Input`s defined on the notification.
//
// This function will be invoked when a toast notification is interacted with.
//
// This will do nothing if the the powershell fallback is in-effect.
func SetActivationCallback(cb func(args string, data []UserData)) {
wintoast.SetActivationCallback(func(appUserModelId, invokedArgs string, userData []wintoast.UserData) {
cb(invokedArgs, userData)
})
}
type AppData = wintoast.AppData
// SetAppData sets application metadata in the Windows Registry.
// This is required to display the application name, as well as any branding.
// Registry is global state, hence it makes sense to set it global.
func SetAppData(data AppData) error {
return wintoast.SetAppData(data)
}

89
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/wintoast/bind.go vendored Normal file
View File

@@ -0,0 +1,89 @@
// Package wintoast provides a pure-Go implementation of toast notifications on Windows.
package wintoast
import "errors"
// AppData describes the application to the Windows Runtime.
// See toast.Notification for more thorough documentation off these fields.
type AppData struct {
AppID string
GUID string
ActivationExe string // optional
IconPath string // optional
IconBackgroundColor string // optional
}
// UserData contains Key:Value pairs generated within the notification, based
// on the XML content of the notification. Specifically, all inputs within
// the XML will generate a corresponding UserData struct.
type UserData struct {
Key string
Value string
}
// Callback is a function that gets invoked when the notification is activated.
type Callback func(appUserModelId string, invokedArgs string, userData []UserData)
// SetAppData teaches the Windows Runtime about our application and establishes the activation GUID
// so Windows will know how to invoke us back.
func SetAppData(data AppData) (err error) {
return setAppData(data)
}
// SetActivationCallback establishes the callback `cb` to be invoked when
// the toast notification is activated. This callback instance should handle
// being activated from any available toast notification.
func SetActivationCallback(cb Callback) {
callback = cb
}
// Push a notification described by the XML to the Windows Runtime.
//
// App data should be set first via a call to SetAppData before calling
// this function.
//
// If the powershell fallback is engaged, activation callbacks will not
// work as expected and the COM error will still be returned.
func Push(appID, xml string, op ...option) error {
var opts options
for _, opt := range op {
opt(&opts)
}
if opts.PowershellPreferred {
return pushPowershell(xml)
}
if appID == "" {
appID = appData.AppID
}
if err := pushCOM(appID, xml); err != nil {
if opts.PowershellFallback {
return errors.Join(err, pushPowershell(xml))
}
return err
}
return nil
}
type options struct {
PowershellFallback bool
PowershellPreferred bool
}
type option func(*options)
// PreferPowershell indicates to use the powershell method by default.
// COM will not be used.
func PreferPowershell(opt *options) {
opt.PowershellPreferred = true
}
// PowershellFallback specifies to use the powershell method as a fallback
// if the COM api fails.
func PowershellFallback(opt *options) {
opt.PowershellFallback = true
}
// callback is the global callback reference that is invoked by Activate.
//
// NOTE(jfm): synchronize access to this?
var callback Callback = func(model, args string, data []UserData) {}

21
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/wintoast/bind_noop.go vendored Normal file
View File

@@ -0,0 +1,21 @@
//go:build !windows
package wintoast
var appData AppData
func setAppData(data AppData) error {
return nil
}
func generateToast(appID string, xml string) error {
return nil
}
func pushPowershell(xml string) error {
return nil
}
func pushCOM(appID, xml string) error {
return nil
}

211
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/wintoast/bind_windows.go vendored Normal file
View File

@@ -0,0 +1,211 @@
//go:build windows
package wintoast
import (
"errors"
"fmt"
"io"
"os"
"os/exec"
"sync/atomic"
"syscall"
"unsafe"
"git.sr.ht/~jackmordaunt/go-toast/v2/internal/winrt/data/xml/dom"
"git.sr.ht/~jackmordaunt/go-toast/v2/internal/winrt/ui/notifications"
"git.sr.ht/~jackmordaunt/go-toast/v2/tmpl"
"github.com/go-ole/go-ole"
"golang.org/x/sys/windows"
)
func pushPowershell(xml string) error {
f, err := os.CreateTemp("", "*.ps1")
if err != nil {
return fmt.Errorf("creating temporary script file: %w", err)
}
defer func() { err = errors.Join(err, os.Remove(f.Name())) }()
// This BOM ensures we can support non-ascii characters in the toast content.
bomUtf8 := []byte{0xef, 0xbb, 0xbf}
if _, err := f.Write(bomUtf8); err != nil {
return fmt.Errorf("writing utf8 byte marker: %w", err)
}
if err := buildPowershell(xml, f); err != nil {
return fmt.Errorf("generating powershell script: %w", err)
}
if err := f.Close(); err != nil {
return fmt.Errorf("closing script file: %w", err)
}
cmd := exec.Command("PowerShell", "-ExecutionPolicy", "Bypass", "-File", f.Name())
cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
if out, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("executing powershell: %q: %w", string(out), err)
}
return nil
}
func buildPowershell(xml string, w io.Writer) error {
type scriptData struct {
AppID string
XML string
}
return tmpl.ScriptTemplate.Execute(w, scriptData{AppID: appData.AppID, XML: xml})
}
// HRESULT E_NOINTERFACE
const errNoInterface = 0x80004002
var comDisabled atomic.Bool
func pushCOM(appID, xml string) (err error) {
if comDisabled.Load() {
return nil
}
defer func() {
// On Windows 7 WinRT interfaces can be stubbed out, and fail to produce
// error values. This leads to a panic when trying to use the interface.
// This recover transforms such panics back into an error value for the
// caller.
//
// If the error is "interface not supported" we will permanently disable
// this API henceforth.
if v := recover(); v != nil {
if verr, ok := v.(error); ok {
err = verr
}
if oleErr, ok := v.(*ole.OleError); ok {
if oleErr.Code() == errNoInterface {
comDisabled.Store(true)
}
}
}
}()
if err := initialize(); err != nil {
return err
}
if err := registerClassFactory(ClassFactory); err != nil {
return fmt.Errorf("registering class factory: %w", err)
}
doc, err := dom.NewXmlDocument()
if err != nil {
return fmt.Errorf("dom.NewXmlDocument(): %w", err)
}
defer doc.Release()
if err := doc.LoadXml(xml); err != nil {
return fmt.Errorf("doc.LoadXml(tmpl): %w", err)
}
manager, err := notifications.GetDefault()
if err != nil {
return fmt.Errorf("notifications.GetDefault(): %w", err)
}
defer manager.Release()
notifier, err := manager.CreateToastNotifierWithId(appID)
if err != nil {
return fmt.Errorf("manager.CreateToastNotifier(%q): %w", appID, err)
}
defer notifier.Release()
toast, err := notifications.CreateToastNotification(doc)
if err != nil {
return fmt.Errorf("notifications.CreateToastNotification(doc): %w", err)
}
defer toast.Release()
if err := notifier.Show(toast); err != nil {
return fmt.Errorf("notifier.Show(): %w", err)
}
return nil
}
func setAppData(data AppData) (err error) {
appDataMu.Lock()
defer appDataMu.Unlock()
// Early out if we have already set this data.
//
// In the case the data is empty, we don't want to overrite
// all of the registry entries to empty.
//
// This allows the caller to either globally set the app data
// or provide it per notification.
if appData == data || data.AppID == "" {
return nil
}
if data.GUID != "" {
GUID_ImplNotificationActivationCallback = ole.NewGUID(data.GUID)
}
// Keep a copy of the saved data for later.
defer func() {
if err == nil {
appData = data
}
}()
if err := setAppDataFunc(data); err != nil {
return err
}
return nil
}
var initialized atomic.Bool
// initialize attempts to initialize the Windows Runtime.
// Each invocation will retry RoInitialize until a successful initialization
// is achieved. Once initialized, we avoid invoking RoInitialize since subsequent
// reinitialization generates errors.
func initialize() (err error) {
if initialized.CompareAndSwap(false, true) {
if err := ole.RoInitialize(1); err != nil {
return fmt.Errorf("RoInitialize: %w", err)
}
}
return nil
}
// sliceUserDataFromUnsafe builds a slice of UserData out of an unsafe pointer.
func sliceUserDataFromUnsafe(ptr unsafe.Pointer, count int) []UserData {
// Layout mirrors the memory layout of the C struct that contains this data.
// I'm not sure if there's special alignment or packing - though I don't notice
// anything in the definition to indicate as such.
type layout struct {
Key unsafe.Pointer
Value unsafe.Pointer
}
// Create a new slice with the appropriate length
out := make([]UserData, count)
// Create a slice with the unsafe data layout.
tmp := unsafe.Slice((*layout)(ptr), count)
// Convert the unsafe layout to safe strings.
for ii, it := range tmp {
out[ii] = UserData{
Key: windows.UTF16PtrToString((*uint16)(it.Key)),
Value: windows.UTF16PtrToString((*uint16)(it.Value)),
}
}
return out
}

179
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/wintoast/impl.go vendored Normal file
View File

@@ -0,0 +1,179 @@
//go:build windows
// This file contains our pure-Go implementations of two COM objects that we need
// to render toast notifications: IClassFactory and INotificationActivationCallback.
//
// More specifically we allocate the C callable functions that can be used to populate
// the vtable at runtime.
//
// Unfortunately these functions have to be declared as var not const because the callbacks
// are built at runtime. They are declared globally because `syscall.NewCallback` never
// releases the memory it allocates for the functions thus causing an unsolvable memory
// leak if we were to allocate these per-notification.
//
// The other COM interfaces we are interacting with are auto-generated from metadata.
// However the INotificationActivationCallback is undocumented, so we have to define
// it entirely ourselves.
//
// The definitions are derived from:
// - <combase.h>
// - <NotificationActivationCallback.h>
package wintoast
import (
"runtime"
"syscall"
"unsafe"
"github.com/go-ole/go-ole"
"golang.org/x/sys/windows"
)
// Interface GUIDS. These GUIDS are predefined by the Windows Runtime, identifying the various
// interfaces we want to make use of.
var (
IID_IClassFactory = ole.NewGUID("{00000001-0000-0000-C000-000000000046}")
IID_INotificationActivationCallback = ole.NewGUID("{53E31837-6600-4A81-9395-75CFFE746F94}")
)
// This default GUID is for our implementation.
// This was generated and should not collide with any other GUID.
// It's preferable for the application to override this value with its own generated GUID.
var GUID_ImplNotificationActivationCallback = ole.NewGUID("{0F82E845-CB89-4039-BDBF-67CA33254C76}")
type (
// IClassFactory defines the factory that builds our INotificationActivationCallback instance.
// Windows Runtime loves factories.
IClassFactory struct {
VTable *IClassFactoryVtbl
}
IClassFactoryVtbl struct {
ole.IUnknownVtbl
CreateInstance uintptr
LockServer uintptr
}
)
type (
// INotificationActivationCallback receives activations from toast notifications.
INotificationActivationCallback struct {
VTable *INotificationActivationCallbackVtbl
}
INotificationActivationCallbackVtbl struct {
ole.IUnknownVtbl
Activate uintptr
}
)
/*
Strictly speaking we shouldn't need to pin the static objects. They
are package-globals and wont be garabge collected. No harm in being
extra careful, though.
*/
var pinner runtime.Pinner
func init() {
pinner.Pin(ClassFactory)
pinner.Pin(ClassFactory.VTable)
pinner.Pin(NotificationActivationCallback)
pinner.Pin(NotificationActivationCallback.VTable)
}
// Static implementations for the IClassFactory.
var (
ClassFactory = &IClassFactory{
VTable: &IClassFactoryVtbl{
IUnknownVtbl: ole.IUnknownVtbl{
QueryInterface: IClassFactory_QueryInterface,
AddRef: IClassFactory_AddRef,
Release: IClassFactory_Release,
},
LockServer: IClassFactory_LockServer,
CreateInstance: IClassFactory_CreateInstance,
},
}
IClassFactory_AddRef = syscall.NewCallback(func(this *IClassFactory) (re uintptr) {
return uintptr(1)
})
IClassFactory_Release = syscall.NewCallback(func(this *IClassFactory) (re uintptr) {
return uintptr(1)
})
IClassFactory_QueryInterface = syscall.NewCallback(func(this *IClassFactory, riid *ole.GUID, out unsafe.Pointer) (re uintptr) {
if !ole.IsEqualGUID(riid, IID_IClassFactory) &&
!ole.IsEqualGUID(riid, ole.IID_IUnknown) {
return ole.E_NOINTERFACE
}
*(**IClassFactory)(out) = this
return ole.S_OK
})
IClassFactory_LockServer = syscall.NewCallback(func(this *IClassFactory, flock uintptr) (ret uintptr) {
return ole.S_OK
})
IClassFactory_CreateInstance = syscall.NewCallback(func(this *IClassFactory, punkOuter *ole.IUnknown, riid *ole.GUID, out unsafe.Pointer) (re uintptr) {
if punkOuter != nil {
// Should be CLASS_E_NOAGGREGATION but ole doesn't define this.
return ole.E_NOINTERFACE
}
if !ole.IsEqualGUID(riid, IID_INotificationActivationCallback) &&
!ole.IsEqualGUID(riid, ole.IID_IUnknown) {
return ole.E_NOINTERFACE
}
*(**INotificationActivationCallback)(out) = NotificationActivationCallback
return ole.S_OK
})
)
// Static implementations for the INotificationActivationCallback.
var (
NotificationActivationCallback = &INotificationActivationCallback{
VTable: &INotificationActivationCallbackVtbl{
IUnknownVtbl: ole.IUnknownVtbl{
QueryInterface: INotificationActivationCallback_QueryInterface,
AddRef: INotificationActivationCallback_AddRef,
Release: INotificationActivationCallback_Release,
},
Activate: INotificationActivationCallback_Activate,
},
}
INotificationActivationCallback_AddRef = syscall.NewCallback(func(this *INotificationActivationCallback) (re uintptr) {
return uintptr(1)
})
INotificationActivationCallback_Release = syscall.NewCallback(func(this *INotificationActivationCallback) (re uintptr) {
return uintptr(1)
})
INotificationActivationCallback_QueryInterface = syscall.NewCallback(func(this *INotificationActivationCallback, riid *ole.GUID, out unsafe.Pointer) (re uintptr) {
if !ole.IsEqualGUID(riid, IID_INotificationActivationCallback) &&
!ole.IsEqualGUID(riid, ole.IID_IUnknown) {
return ole.E_NOINTERFACE
}
*(**INotificationActivationCallback)(out) = this
return ole.S_OK
})
// Activate is our re-entrance into Go from Windows. This is the magic.
INotificationActivationCallback_Activate = syscall.NewCallback(func(
this unsafe.Pointer,
appUserModelId unsafe.Pointer,
invokedArgs unsafe.Pointer,
data unsafe.Pointer,
count uint32,
) (ret uintptr) {
callback(
windows.UTF16PtrToString((*uint16)(appUserModelId)),
windows.UTF16PtrToString((*uint16)(invokedArgs)),
sliceUserDataFromUnsafe(data, int(count)),
)
return
})
)

37
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/wintoast/procs.go vendored Normal file
View File

@@ -0,0 +1,37 @@
//go:build windows
package wintoast
import (
"unsafe"
"github.com/go-ole/go-ole"
"golang.org/x/sys/windows"
)
var (
// Define procs that go-ole doesn't provide. This is how we register our Go-implemented
// COM objects.
modcombase = windows.NewLazySystemDLL("combase.dll")
procRegisterClassObject = modcombase.NewProc("CoRegisterClassObject")
)
// registerClassFactory teaches the Windows Runtime about our factory that can allocate
// instances of our ActivationCallback.
func registerClassFactory(factory *IClassFactory) error {
// cookie is used as a handle to this class. It is used when calling CoRevokeClassObject
// which unregisters the class. We don't need it until we plan to revoke this registration
// for some reason.
var cookie int64
hr, _, _ := procRegisterClassObject.Call(
uintptr(unsafe.Pointer(GUID_ImplNotificationActivationCallback)),
uintptr(unsafe.Pointer(factory)),
uintptr(ole.CLSCTX_LOCAL_SERVER),
uintptr(1), /* REGCLS_MULTIPLEUSE */
uintptr(unsafe.Pointer(&cookie)),
)
if hr != ole.S_OK {
return ole.NewError(hr)
}
return nil
}

110
vendor/git.sr.ht/~jackmordaunt/go-toast/v2/wintoast/registry.go vendored Normal file
View File

@@ -0,0 +1,110 @@
//go:build windows
// This file contains registry manipulation code.
// This logic is orthogonal to, but works in tandem with the COM code; since the
// Windows Runtime uses the registry as it's primary source of state.
package wintoast
import (
"fmt"
"path/filepath"
"sync"
"golang.org/x/sys/windows/registry"
)
var (
// allows diffing the new call from the previous so that we can early-out,
// and avoid touching the registry more than necessary.
// It also allows empty app data to be supplied to the Notifcation type,
// without erasing the data that has been set via the global function.
appData AppData
appDataMu sync.Mutex
)
// Overridden in testing.
var (
writeStringValue = writeStringValueImpl
setAppDataFunc = setAppDataImpl
)
var (
// appKeyRoot is the root path for app metadata.
appKeyRoot = filepath.Join("SOFTWARE", "Classes", "AppUserModelId")
// activationKey is the root path to the activation executable.
activationKey = filepath.Join("SOFTWARE", "Classes", "CLSID", GUID_ImplNotificationActivationCallback.String(), "LocalServer32")
)
// The Windows registry package uses empty string for the "(Default)" key.
const registryDefaultKey string = ""
func setAppDataImpl(data AppData) error {
if data.AppID == "" {
return fmt.Errorf("empty app ID")
}
appKey := filepath.Join(appKeyRoot, data.AppID)
if err := writeStringValue(appKey, "DisplayName", data.AppID); err != nil {
return err
}
// CustomActivator teaches Window what COM class to use as the callback when
// a toast notification is activated.
if err := writeStringValue(appKey, "CustomActivator", GUID_ImplNotificationActivationCallback.String()); err != nil {
return err
}
if data.IconPath != "" {
if err := writeStringValue(appKey, "IconUri", data.IconPath); err != nil {
return err
}
}
if data.IconBackgroundColor != "" {
if err := writeStringValue(appKey, "IconBackgroundColor", data.IconBackgroundColor); err != nil {
return err
}
}
if data.ActivationExe != "" {
if err := writeStringValue(activationKey, registryDefaultKey, data.ActivationExe); err != nil {
return fmt.Errorf("setting activation executable: %w", err)
}
}
return nil
}
// writeStringValue writes a string value to the path, where name is the subkey and
// value is the literal value.
func writeStringValueImpl(path, name, value string) error {
if keyExists(path, name) {
return nil
}
key, _, err := registry.CreateKey(registry.CURRENT_USER, path, registry.SET_VALUE)
if err != nil {
return fmt.Errorf("opening registry key: %s: %w", path, err)
}
if err := key.SetStringValue(name, value); err != nil {
return fmt.Errorf("setting string value: (%s) %s=%s: %w", path, name, value, err)
}
if err := key.Close(); err != nil {
return fmt.Errorf("closing key: %s: %w", path, err)
}
return nil
}
// keyExists returns true if the key exists.
func keyExists(path, name string) bool {
key, err := registry.OpenKey(registry.CURRENT_USER, path, registry.READ)
if err != nil {
return false
}
defer key.Close()
v, _, err := key.GetStringValue(name)
if err != nil {
return false
}
return v != ""
}

1
vendor/github.com/Microsoft/go-winio/.gitattributes generated vendored Normal file
View File

@@ -0,0 +1 @@
* text=auto eol=lf

10
vendor/github.com/Microsoft/go-winio/.gitignore generated vendored Normal file
View File

@@ -0,0 +1,10 @@
.vscode/
*.exe
# testing
testdata
# go workspaces
go.work
go.work.sum

147
vendor/github.com/Microsoft/go-winio/.golangci.yml generated vendored Normal file
View File

@@ -0,0 +1,147 @@
linters:
enable:
# style
- containedctx # struct contains a context
- dupl # duplicate code
- errname # erorrs are named correctly
- nolintlint # "//nolint" directives are properly explained
- revive # golint replacement
- unconvert # unnecessary conversions
- wastedassign
# bugs, performance, unused, etc ...
- contextcheck # function uses a non-inherited context
- errorlint # errors not wrapped for 1.13
- exhaustive # check exhaustiveness of enum switch statements
- gofmt # files are gofmt'ed
- gosec # security
- nilerr # returns nil even with non-nil error
- thelper # test helpers without t.Helper()
- unparam # unused function params
issues:
exclude-dirs:
- pkg/etw/sample
exclude-rules:
# err is very often shadowed in nested scopes
- linters:
- govet
text: '^shadow: declaration of "err" shadows declaration'
# ignore long lines for skip autogen directives
- linters:
- revive
text: "^line-length-limit: "
source: "^//(go:generate|sys) "
#TODO: remove after upgrading to go1.18
# ignore comment spacing for nolint and sys directives
- linters:
- revive
text: "^comment-spacings: no space between comment delimiter and comment text"
source: "//(cspell:|nolint:|sys |todo)"
# not on go 1.18 yet, so no any
- linters:
- revive
text: "^use-any: since GO 1.18 'interface{}' can be replaced by 'any'"
# allow unjustified ignores of error checks in defer statements
- linters:
- nolintlint
text: "^directive `//nolint:errcheck` should provide explanation"
source: '^\s*defer '
# allow unjustified ignores of error lints for io.EOF
- linters:
- nolintlint
text: "^directive `//nolint:errorlint` should provide explanation"
source: '[=|!]= io.EOF'
linters-settings:
exhaustive:
default-signifies-exhaustive: true
govet:
enable-all: true
disable:
# struct order is often for Win32 compat
# also, ignore pointer bytes/GC issues for now until performance becomes an issue
- fieldalignment
nolintlint:
require-explanation: true
require-specific: true
revive:
# revive is more configurable than static check, so likely the preferred alternative to static-check
# (once the perf issue is solved: https://github.com/golangci/golangci-lint/issues/2997)
enable-all-rules:
true
# https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md
rules:
# rules with required arguments
- name: argument-limit
disabled: true
- name: banned-characters
disabled: true
- name: cognitive-complexity
disabled: true
- name: cyclomatic
disabled: true
- name: file-header
disabled: true
- name: function-length
disabled: true
- name: function-result-limit
disabled: true
- name: max-public-structs
disabled: true
# geneally annoying rules
- name: add-constant # complains about any and all strings and integers
disabled: true
- name: confusing-naming # we frequently use "Foo()" and "foo()" together
disabled: true
- name: flag-parameter # excessive, and a common idiom we use
disabled: true
- name: unhandled-error # warns over common fmt.Print* and io.Close; rely on errcheck instead
disabled: true
# general config
- name: line-length-limit
arguments:
- 140
- name: var-naming
arguments:
- []
- - CID
- CRI
- CTRD
- DACL
- DLL
- DOS
- ETW
- FSCTL
- GCS
- GMSA
- HCS
- HV
- IO
- LCOW
- LDAP
- LPAC
- LTSC
- MMIO
- NT
- OCI
- PMEM
- PWSH
- RX
- SACl
- SID
- SMB
- TX
- VHD
- VHDX
- VMID
- VPCI
- WCOW
- WIM

1
vendor/github.com/Microsoft/go-winio/CODEOWNERS generated vendored Normal file
View File

@@ -0,0 +1 @@
* @microsoft/containerplat

22
vendor/github.com/Microsoft/go-winio/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,22 @@
The MIT License (MIT)
Copyright (c) 2015 Microsoft
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

89
vendor/github.com/Microsoft/go-winio/README.md generated vendored Normal file
View File

@@ -0,0 +1,89 @@
# go-winio [![Build Status](https://github.com/microsoft/go-winio/actions/workflows/ci.yml/badge.svg)](https://github.com/microsoft/go-winio/actions/workflows/ci.yml)
This repository contains utilities for efficiently performing Win32 IO operations in
Go. Currently, this is focused on accessing named pipes and other file handles, and
for using named pipes as a net transport.
This code relies on IO completion ports to avoid blocking IO on system threads, allowing Go
to reuse the thread to schedule another goroutine. This limits support to Windows Vista and
newer operating systems. This is similar to the implementation of network sockets in Go's net
package.
Please see the LICENSE file for licensing information.
## Contributing
This project welcomes contributions and suggestions.
Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that
you have the right to, and actually do, grant us the rights to use your contribution.
For details, visit [Microsoft CLA](https://cla.microsoft.com).
When you submit a pull request, a CLA-bot will automatically determine whether you need to
provide a CLA and decorate the PR appropriately (e.g., label, comment).
Simply follow the instructions provided by the bot.
You will only need to do this once across all repos using our CLA.
Additionally, the pull request pipeline requires the following steps to be performed before
mergining.
### Code Sign-Off
We require that contributors sign their commits using [`git commit --signoff`][git-commit-s]
to certify they either authored the work themselves or otherwise have permission to use it in this project.
A range of commits can be signed off using [`git rebase --signoff`][git-rebase-s].
Please see [the developer certificate](https://developercertificate.org) for more info,
as well as to make sure that you can attest to the rules listed.
Our CI uses the DCO Github app to ensure that all commits in a given PR are signed-off.
### Linting
Code must pass a linting stage, which uses [`golangci-lint`][lint].
The linting settings are stored in [`.golangci.yaml`](./.golangci.yaml), and can be run
automatically with VSCode by adding the following to your workspace or folder settings:
```json
"go.lintTool": "golangci-lint",
"go.lintOnSave": "package",
```
Additional editor [integrations options are also available][lint-ide].
Alternatively, `golangci-lint` can be [installed locally][lint-install] and run from the repo root:
```shell
# use . or specify a path to only lint a package
# to show all lint errors, use flags "--max-issues-per-linter=0 --max-same-issues=0"
> golangci-lint run ./...
```
### Go Generate
The pipeline checks that auto-generated code, via `go generate`, are up to date.
This can be done for the entire repo:
```shell
> go generate ./...
```
## Code of Conduct
This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
## Special Thanks
Thanks to [natefinch][natefinch] for the inspiration for this library.
See [npipe](https://github.com/natefinch/npipe) for another named pipe implementation.
[lint]: https://golangci-lint.run/
[lint-ide]: https://golangci-lint.run/usage/integrations/#editor-integration
[lint-install]: https://golangci-lint.run/usage/install/#local-installation
[git-commit-s]: https://git-scm.com/docs/git-commit#Documentation/git-commit.txt--s
[git-rebase-s]: https://git-scm.com/docs/git-rebase#Documentation/git-rebase.txt---signoff
[natefinch]: https://github.com/natefinch

41
vendor/github.com/Microsoft/go-winio/SECURITY.md generated vendored Normal file
View File

@@ -0,0 +1,41 @@
<!-- BEGIN MICROSOFT SECURITY.MD V0.0.7 BLOCK -->
## Security
Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
## Reporting Security Issues
**Please do not report security vulnerabilities through public GitHub issues.**
Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc).
Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
* Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
* Full paths of source file(s) related to the manifestation of the issue
* The location of the affected source code (tag/branch/commit or direct URL)
* Any special configuration required to reproduce the issue
* Step-by-step instructions to reproduce the issue
* Proof-of-concept or exploit code (if possible)
* Impact of the issue, including how an attacker might exploit the issue
This information will help us triage your report more quickly.
If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
## Preferred Languages
We prefer all communications to be in English.
## Policy
Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
<!-- END MICROSOFT SECURITY.MD BLOCK -->

287
vendor/github.com/Microsoft/go-winio/backup.go generated vendored Normal file
View File

@@ -0,0 +1,287 @@
//go:build windows
// +build windows
package winio
import (
"encoding/binary"
"errors"
"fmt"
"io"
"os"
"runtime"
"unicode/utf16"
"github.com/Microsoft/go-winio/internal/fs"
"golang.org/x/sys/windows"
)
//sys backupRead(h windows.Handle, b []byte, bytesRead *uint32, abort bool, processSecurity bool, context *uintptr) (err error) = BackupRead
//sys backupWrite(h windows.Handle, b []byte, bytesWritten *uint32, abort bool, processSecurity bool, context *uintptr) (err error) = BackupWrite
const (
BackupData = uint32(iota + 1)
BackupEaData
BackupSecurity
BackupAlternateData
BackupLink
BackupPropertyData
BackupObjectId //revive:disable-line:var-naming ID, not Id
BackupReparseData
BackupSparseBlock
BackupTxfsData
)
const (
StreamSparseAttributes = uint32(8)
)
//nolint:revive // var-naming: ALL_CAPS
const (
WRITE_DAC = windows.WRITE_DAC
WRITE_OWNER = windows.WRITE_OWNER
ACCESS_SYSTEM_SECURITY = windows.ACCESS_SYSTEM_SECURITY
)
// BackupHeader represents a backup stream of a file.
type BackupHeader struct {
//revive:disable-next-line:var-naming ID, not Id
Id uint32 // The backup stream ID
Attributes uint32 // Stream attributes
Size int64 // The size of the stream in bytes
Name string // The name of the stream (for BackupAlternateData only).
Offset int64 // The offset of the stream in the file (for BackupSparseBlock only).
}
type win32StreamID struct {
StreamID uint32
Attributes uint32
Size uint64
NameSize uint32
}
// BackupStreamReader reads from a stream produced by the BackupRead Win32 API and produces a series
// of BackupHeader values.
type BackupStreamReader struct {
r io.Reader
bytesLeft int64
}
// NewBackupStreamReader produces a BackupStreamReader from any io.Reader.
func NewBackupStreamReader(r io.Reader) *BackupStreamReader {
return &BackupStreamReader{r, 0}
}
// Next returns the next backup stream and prepares for calls to Read(). It skips the remainder of the current stream if
// it was not completely read.
func (r *BackupStreamReader) Next() (*BackupHeader, error) {
if r.bytesLeft > 0 { //nolint:nestif // todo: flatten this
if s, ok := r.r.(io.Seeker); ok {
// Make sure Seek on io.SeekCurrent sometimes succeeds
// before trying the actual seek.
if _, err := s.Seek(0, io.SeekCurrent); err == nil {
if _, err = s.Seek(r.bytesLeft, io.SeekCurrent); err != nil {
return nil, err
}
r.bytesLeft = 0
}
}
if _, err := io.Copy(io.Discard, r); err != nil {
return nil, err
}
}
var wsi win32StreamID
if err := binary.Read(r.r, binary.LittleEndian, &wsi); err != nil {
return nil, err
}
hdr := &BackupHeader{
Id: wsi.StreamID,
Attributes: wsi.Attributes,
Size: int64(wsi.Size),
}
if wsi.NameSize != 0 {
name := make([]uint16, int(wsi.NameSize/2))
if err := binary.Read(r.r, binary.LittleEndian, name); err != nil {
return nil, err
}
hdr.Name = windows.UTF16ToString(name)
}
if wsi.StreamID == BackupSparseBlock {
if err := binary.Read(r.r, binary.LittleEndian, &hdr.Offset); err != nil {
return nil, err
}
hdr.Size -= 8
}
r.bytesLeft = hdr.Size
return hdr, nil
}
// Read reads from the current backup stream.
func (r *BackupStreamReader) Read(b []byte) (int, error) {
if r.bytesLeft == 0 {
return 0, io.EOF
}
if int64(len(b)) > r.bytesLeft {
b = b[:r.bytesLeft]
}
n, err := r.r.Read(b)
r.bytesLeft -= int64(n)
if err == io.EOF {
err = io.ErrUnexpectedEOF
} else if r.bytesLeft == 0 && err == nil {
err = io.EOF
}
return n, err
}
// BackupStreamWriter writes a stream compatible with the BackupWrite Win32 API.
type BackupStreamWriter struct {
w io.Writer
bytesLeft int64
}
// NewBackupStreamWriter produces a BackupStreamWriter on top of an io.Writer.
func NewBackupStreamWriter(w io.Writer) *BackupStreamWriter {
return &BackupStreamWriter{w, 0}
}
// WriteHeader writes the next backup stream header and prepares for calls to Write().
func (w *BackupStreamWriter) WriteHeader(hdr *BackupHeader) error {
if w.bytesLeft != 0 {
return fmt.Errorf("missing %d bytes", w.bytesLeft)
}
name := utf16.Encode([]rune(hdr.Name))
wsi := win32StreamID{
StreamID: hdr.Id,
Attributes: hdr.Attributes,
Size: uint64(hdr.Size),
NameSize: uint32(len(name) * 2),
}
if hdr.Id == BackupSparseBlock {
// Include space for the int64 block offset
wsi.Size += 8
}
if err := binary.Write(w.w, binary.LittleEndian, &wsi); err != nil {
return err
}
if len(name) != 0 {
if err := binary.Write(w.w, binary.LittleEndian, name); err != nil {
return err
}
}
if hdr.Id == BackupSparseBlock {
if err := binary.Write(w.w, binary.LittleEndian, hdr.Offset); err != nil {
return err
}
}
w.bytesLeft = hdr.Size
return nil
}
// Write writes to the current backup stream.
func (w *BackupStreamWriter) Write(b []byte) (int, error) {
if w.bytesLeft < int64(len(b)) {
return 0, fmt.Errorf("too many bytes by %d", int64(len(b))-w.bytesLeft)
}
n, err := w.w.Write(b)
w.bytesLeft -= int64(n)
return n, err
}
// BackupFileReader provides an io.ReadCloser interface on top of the BackupRead Win32 API.
type BackupFileReader struct {
f *os.File
includeSecurity bool
ctx uintptr
}
// NewBackupFileReader returns a new BackupFileReader from a file handle. If includeSecurity is true,
// Read will attempt to read the security descriptor of the file.
func NewBackupFileReader(f *os.File, includeSecurity bool) *BackupFileReader {
r := &BackupFileReader{f, includeSecurity, 0}
return r
}
// Read reads a backup stream from the file by calling the Win32 API BackupRead().
func (r *BackupFileReader) Read(b []byte) (int, error) {
var bytesRead uint32
err := backupRead(windows.Handle(r.f.Fd()), b, &bytesRead, false, r.includeSecurity, &r.ctx)
if err != nil {
return 0, &os.PathError{Op: "BackupRead", Path: r.f.Name(), Err: err}
}
runtime.KeepAlive(r.f)
if bytesRead == 0 {
return 0, io.EOF
}
return int(bytesRead), nil
}
// Close frees Win32 resources associated with the BackupFileReader. It does not close
// the underlying file.
func (r *BackupFileReader) Close() error {
if r.ctx != 0 {
_ = backupRead(windows.Handle(r.f.Fd()), nil, nil, true, false, &r.ctx)
runtime.KeepAlive(r.f)
r.ctx = 0
}
return nil
}
// BackupFileWriter provides an io.WriteCloser interface on top of the BackupWrite Win32 API.
type BackupFileWriter struct {
f *os.File
includeSecurity bool
ctx uintptr
}
// NewBackupFileWriter returns a new BackupFileWriter from a file handle. If includeSecurity is true,
// Write() will attempt to restore the security descriptor from the stream.
func NewBackupFileWriter(f *os.File, includeSecurity bool) *BackupFileWriter {
w := &BackupFileWriter{f, includeSecurity, 0}
return w
}
// Write restores a portion of the file using the provided backup stream.
func (w *BackupFileWriter) Write(b []byte) (int, error) {
var bytesWritten uint32
err := backupWrite(windows.Handle(w.f.Fd()), b, &bytesWritten, false, w.includeSecurity, &w.ctx)
if err != nil {
return 0, &os.PathError{Op: "BackupWrite", Path: w.f.Name(), Err: err}
}
runtime.KeepAlive(w.f)
if int(bytesWritten) != len(b) {
return int(bytesWritten), errors.New("not all bytes could be written")
}
return len(b), nil
}
// Close frees Win32 resources associated with the BackupFileWriter. It does not
// close the underlying file.
func (w *BackupFileWriter) Close() error {
if w.ctx != 0 {
_ = backupWrite(windows.Handle(w.f.Fd()), nil, nil, true, false, &w.ctx)
runtime.KeepAlive(w.f)
w.ctx = 0
}
return nil
}
// OpenForBackup opens a file or directory, potentially skipping access checks if the backup
// or restore privileges have been acquired.
//
// If the file opened was a directory, it cannot be used with Readdir().
func OpenForBackup(path string, access uint32, share uint32, createmode uint32) (*os.File, error) {
h, err := fs.CreateFile(path,
fs.AccessMask(access),
fs.FileShareMode(share),
nil,
fs.FileCreationDisposition(createmode),
fs.FILE_FLAG_BACKUP_SEMANTICS|fs.FILE_FLAG_OPEN_REPARSE_POINT,
0,
)
if err != nil {
err = &os.PathError{Op: "open", Path: path, Err: err}
return nil, err
}
return os.NewFile(uintptr(h), path), nil
}

22
vendor/github.com/Microsoft/go-winio/doc.go generated vendored Normal file
View File

@@ -0,0 +1,22 @@
// This package provides utilities for efficiently performing Win32 IO operations in Go.
// Currently, this package is provides support for genreal IO and management of
// - named pipes
// - files
// - [Hyper-V sockets]
//
// This code is similar to Go's [net] package, and uses IO completion ports to avoid
// blocking IO on system threads, allowing Go to reuse the thread to schedule other goroutines.
//
// This limits support to Windows Vista and newer operating systems.
//
// Additionally, this package provides support for:
// - creating and managing GUIDs
// - writing to [ETW]
// - opening and manageing VHDs
// - parsing [Windows Image files]
// - auto-generating Win32 API code
//
// [Hyper-V sockets]: https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/user-guide/make-integration-service
// [ETW]: https://docs.microsoft.com/en-us/windows-hardware/drivers/devtest/event-tracing-for-windows--etw-
// [Windows Image files]: https://docs.microsoft.com/en-us/windows-hardware/manufacture/desktop/work-with-windows-images
package winio

137
vendor/github.com/Microsoft/go-winio/ea.go generated vendored Normal file
View File

@@ -0,0 +1,137 @@
package winio
import (
"bytes"
"encoding/binary"
"errors"
)
type fileFullEaInformation struct {
NextEntryOffset uint32
Flags uint8
NameLength uint8
ValueLength uint16
}
var (
fileFullEaInformationSize = binary.Size(&fileFullEaInformation{})
errInvalidEaBuffer = errors.New("invalid extended attribute buffer")
errEaNameTooLarge = errors.New("extended attribute name too large")
errEaValueTooLarge = errors.New("extended attribute value too large")
)
// ExtendedAttribute represents a single Windows EA.
type ExtendedAttribute struct {
Name string
Value []byte
Flags uint8
}
func parseEa(b []byte) (ea ExtendedAttribute, nb []byte, err error) {
var info fileFullEaInformation
err = binary.Read(bytes.NewReader(b), binary.LittleEndian, &info)
if err != nil {
err = errInvalidEaBuffer
return ea, nb, err
}
nameOffset := fileFullEaInformationSize
nameLen := int(info.NameLength)
valueOffset := nameOffset + int(info.NameLength) + 1
valueLen := int(info.ValueLength)
nextOffset := int(info.NextEntryOffset)
if valueLen+valueOffset > len(b) || nextOffset < 0 || nextOffset > len(b) {
err = errInvalidEaBuffer
return ea, nb, err
}
ea.Name = string(b[nameOffset : nameOffset+nameLen])
ea.Value = b[valueOffset : valueOffset+valueLen]
ea.Flags = info.Flags
if info.NextEntryOffset != 0 {
nb = b[info.NextEntryOffset:]
}
return ea, nb, err
}
// DecodeExtendedAttributes decodes a list of EAs from a FILE_FULL_EA_INFORMATION
// buffer retrieved from BackupRead, ZwQueryEaFile, etc.
func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
for len(b) != 0 {
ea, nb, err := parseEa(b)
if err != nil {
return nil, err
}
eas = append(eas, ea)
b = nb
}
return eas, err
}
func writeEa(buf *bytes.Buffer, ea *ExtendedAttribute, last bool) error {
if int(uint8(len(ea.Name))) != len(ea.Name) {
return errEaNameTooLarge
}
if int(uint16(len(ea.Value))) != len(ea.Value) {
return errEaValueTooLarge
}
entrySize := uint32(fileFullEaInformationSize + len(ea.Name) + 1 + len(ea.Value))
withPadding := (entrySize + 3) &^ 3
nextOffset := uint32(0)
if !last {
nextOffset = withPadding
}
info := fileFullEaInformation{
NextEntryOffset: nextOffset,
Flags: ea.Flags,
NameLength: uint8(len(ea.Name)),
ValueLength: uint16(len(ea.Value)),
}
err := binary.Write(buf, binary.LittleEndian, &info)
if err != nil {
return err
}
_, err = buf.Write([]byte(ea.Name))
if err != nil {
return err
}
err = buf.WriteByte(0)
if err != nil {
return err
}
_, err = buf.Write(ea.Value)
if err != nil {
return err
}
_, err = buf.Write([]byte{0, 0, 0}[0 : withPadding-entrySize])
if err != nil {
return err
}
return nil
}
// EncodeExtendedAttributes encodes a list of EAs into a FILE_FULL_EA_INFORMATION
// buffer for use with BackupWrite, ZwSetEaFile, etc.
func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
var buf bytes.Buffer
for i := range eas {
last := false
if i == len(eas)-1 {
last = true
}
err := writeEa(&buf, &eas[i], last)
if err != nil {
return nil, err
}
}
return buf.Bytes(), nil
}

320
vendor/github.com/Microsoft/go-winio/file.go generated vendored Normal file
View File

@@ -0,0 +1,320 @@
//go:build windows
// +build windows
package winio
import (
"errors"
"io"
"runtime"
"sync"
"sync/atomic"
"syscall"
"time"
"golang.org/x/sys/windows"
)
//sys cancelIoEx(file windows.Handle, o *windows.Overlapped) (err error) = CancelIoEx
//sys createIoCompletionPort(file windows.Handle, port windows.Handle, key uintptr, threadCount uint32) (newport windows.Handle, err error) = CreateIoCompletionPort
//sys getQueuedCompletionStatus(port windows.Handle, bytes *uint32, key *uintptr, o **ioOperation, timeout uint32) (err error) = GetQueuedCompletionStatus
//sys setFileCompletionNotificationModes(h windows.Handle, flags uint8) (err error) = SetFileCompletionNotificationModes
//sys wsaGetOverlappedResult(h windows.Handle, o *windows.Overlapped, bytes *uint32, wait bool, flags *uint32) (err error) = ws2_32.WSAGetOverlappedResult
var (
ErrFileClosed = errors.New("file has already been closed")
ErrTimeout = &timeoutError{}
)
type timeoutError struct{}
func (*timeoutError) Error() string { return "i/o timeout" }
func (*timeoutError) Timeout() bool { return true }
func (*timeoutError) Temporary() bool { return true }
type timeoutChan chan struct{}
var ioInitOnce sync.Once
var ioCompletionPort windows.Handle
// ioResult contains the result of an asynchronous IO operation.
type ioResult struct {
bytes uint32
err error
}
// ioOperation represents an outstanding asynchronous Win32 IO.
type ioOperation struct {
o windows.Overlapped
ch chan ioResult
}
func initIO() {
h, err := createIoCompletionPort(windows.InvalidHandle, 0, 0, 0xffffffff)
if err != nil {
panic(err)
}
ioCompletionPort = h
go ioCompletionProcessor(h)
}
// win32File implements Reader, Writer, and Closer on a Win32 handle without blocking in a syscall.
// It takes ownership of this handle and will close it if it is garbage collected.
type win32File struct {
handle windows.Handle
wg sync.WaitGroup
wgLock sync.RWMutex
closing atomic.Bool
socket bool
readDeadline deadlineHandler
writeDeadline deadlineHandler
}
type deadlineHandler struct {
setLock sync.Mutex
channel timeoutChan
channelLock sync.RWMutex
timer *time.Timer
timedout atomic.Bool
}
// makeWin32File makes a new win32File from an existing file handle.
func makeWin32File(h windows.Handle) (*win32File, error) {
f := &win32File{handle: h}
ioInitOnce.Do(initIO)
_, err := createIoCompletionPort(h, ioCompletionPort, 0, 0xffffffff)
if err != nil {
return nil, err
}
err = setFileCompletionNotificationModes(h, windows.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS|windows.FILE_SKIP_SET_EVENT_ON_HANDLE)
if err != nil {
return nil, err
}
f.readDeadline.channel = make(timeoutChan)
f.writeDeadline.channel = make(timeoutChan)
return f, nil
}
// Deprecated: use NewOpenFile instead.
func MakeOpenFile(h syscall.Handle) (io.ReadWriteCloser, error) {
return NewOpenFile(windows.Handle(h))
}
func NewOpenFile(h windows.Handle) (io.ReadWriteCloser, error) {
// If we return the result of makeWin32File directly, it can result in an
// interface-wrapped nil, rather than a nil interface value.
f, err := makeWin32File(h)
if err != nil {
return nil, err
}
return f, nil
}
// closeHandle closes the resources associated with a Win32 handle.
func (f *win32File) closeHandle() {
f.wgLock.Lock()
// Atomically set that we are closing, releasing the resources only once.
if !f.closing.Swap(true) {
f.wgLock.Unlock()
// cancel all IO and wait for it to complete
_ = cancelIoEx(f.handle, nil)
f.wg.Wait()
// at this point, no new IO can start
windows.Close(f.handle)
f.handle = 0
} else {
f.wgLock.Unlock()
}
}
// Close closes a win32File.
func (f *win32File) Close() error {
f.closeHandle()
return nil
}
// IsClosed checks if the file has been closed.
func (f *win32File) IsClosed() bool {
return f.closing.Load()
}
// prepareIO prepares for a new IO operation.
// The caller must call f.wg.Done() when the IO is finished, prior to Close() returning.
func (f *win32File) prepareIO() (*ioOperation, error) {
f.wgLock.RLock()
if f.closing.Load() {
f.wgLock.RUnlock()
return nil, ErrFileClosed
}
f.wg.Add(1)
f.wgLock.RUnlock()
c := &ioOperation{}
c.ch = make(chan ioResult)
return c, nil
}
// ioCompletionProcessor processes completed async IOs forever.
func ioCompletionProcessor(h windows.Handle) {
for {
var bytes uint32
var key uintptr
var op *ioOperation
err := getQueuedCompletionStatus(h, &bytes, &key, &op, windows.INFINITE)
if op == nil {
panic(err)
}
op.ch <- ioResult{bytes, err}
}
}
// todo: helsaawy - create an asyncIO version that takes a context
// asyncIO processes the return value from ReadFile or WriteFile, blocking until
// the operation has actually completed.
func (f *win32File) asyncIO(c *ioOperation, d *deadlineHandler, bytes uint32, err error) (int, error) {
if err != windows.ERROR_IO_PENDING { //nolint:errorlint // err is Errno
return int(bytes), err
}
if f.closing.Load() {
_ = cancelIoEx(f.handle, &c.o)
}
var timeout timeoutChan
if d != nil {
d.channelLock.Lock()
timeout = d.channel
d.channelLock.Unlock()
}
var r ioResult
select {
case r = <-c.ch:
err = r.err
if err == windows.ERROR_OPERATION_ABORTED { //nolint:errorlint // err is Errno
if f.closing.Load() {
err = ErrFileClosed
}
} else if err != nil && f.socket {
// err is from Win32. Query the overlapped structure to get the winsock error.
var bytes, flags uint32
err = wsaGetOverlappedResult(f.handle, &c.o, &bytes, false, &flags)
}
case <-timeout:
_ = cancelIoEx(f.handle, &c.o)
r = <-c.ch
err = r.err
if err == windows.ERROR_OPERATION_ABORTED { //nolint:errorlint // err is Errno
err = ErrTimeout
}
}
// runtime.KeepAlive is needed, as c is passed via native
// code to ioCompletionProcessor, c must remain alive
// until the channel read is complete.
// todo: (de)allocate *ioOperation via win32 heap functions, instead of needing to KeepAlive?
runtime.KeepAlive(c)
return int(r.bytes), err
}
// Read reads from a file handle.
func (f *win32File) Read(b []byte) (int, error) {
c, err := f.prepareIO()
if err != nil {
return 0, err
}
defer f.wg.Done()
if f.readDeadline.timedout.Load() {
return 0, ErrTimeout
}
var bytes uint32
err = windows.ReadFile(f.handle, b, &bytes, &c.o)
n, err := f.asyncIO(c, &f.readDeadline, bytes, err)
runtime.KeepAlive(b)
// Handle EOF conditions.
if err == nil && n == 0 && len(b) != 0 {
return 0, io.EOF
} else if err == windows.ERROR_BROKEN_PIPE { //nolint:errorlint // err is Errno
return 0, io.EOF
}
return n, err
}
// Write writes to a file handle.
func (f *win32File) Write(b []byte) (int, error) {
c, err := f.prepareIO()
if err != nil {
return 0, err
}
defer f.wg.Done()
if f.writeDeadline.timedout.Load() {
return 0, ErrTimeout
}
var bytes uint32
err = windows.WriteFile(f.handle, b, &bytes, &c.o)
n, err := f.asyncIO(c, &f.writeDeadline, bytes, err)
runtime.KeepAlive(b)
return n, err
}
func (f *win32File) SetReadDeadline(deadline time.Time) error {
return f.readDeadline.set(deadline)
}
func (f *win32File) SetWriteDeadline(deadline time.Time) error {
return f.writeDeadline.set(deadline)
}
func (f *win32File) Flush() error {
return windows.FlushFileBuffers(f.handle)
}
func (f *win32File) Fd() uintptr {
return uintptr(f.handle)
}
func (d *deadlineHandler) set(deadline time.Time) error {
d.setLock.Lock()
defer d.setLock.Unlock()
if d.timer != nil {
if !d.timer.Stop() {
<-d.channel
}
d.timer = nil
}
d.timedout.Store(false)
select {
case <-d.channel:
d.channelLock.Lock()
d.channel = make(chan struct{})
d.channelLock.Unlock()
default:
}
if deadline.IsZero() {
return nil
}
timeoutIO := func() {
d.timedout.Store(true)
close(d.channel)
}
now := time.Now()
duration := deadline.Sub(now)
if deadline.After(now) {
// Deadline is in the future, set a timer to wait
d.timer = time.AfterFunc(duration, timeoutIO)
} else {
// Deadline is in the past. Cancel all pending IO now.
timeoutIO()
}
return nil
}

106
vendor/github.com/Microsoft/go-winio/fileinfo.go generated vendored Normal file
View File

@@ -0,0 +1,106 @@
//go:build windows
// +build windows
package winio
import (
"os"
"runtime"
"unsafe"
"golang.org/x/sys/windows"
)
// FileBasicInfo contains file access time and file attributes information.
type FileBasicInfo struct {
CreationTime, LastAccessTime, LastWriteTime, ChangeTime windows.Filetime
FileAttributes uint32
_ uint32 // padding
}
// alignedFileBasicInfo is a FileBasicInfo, but aligned to uint64 by containing
// uint64 rather than windows.Filetime. Filetime contains two uint32s. uint64
// alignment is necessary to pass this as FILE_BASIC_INFO.
type alignedFileBasicInfo struct {
CreationTime, LastAccessTime, LastWriteTime, ChangeTime uint64
FileAttributes uint32
_ uint32 // padding
}
// GetFileBasicInfo retrieves times and attributes for a file.
func GetFileBasicInfo(f *os.File) (*FileBasicInfo, error) {
bi := &alignedFileBasicInfo{}
if err := windows.GetFileInformationByHandleEx(
windows.Handle(f.Fd()),
windows.FileBasicInfo,
(*byte)(unsafe.Pointer(bi)),
uint32(unsafe.Sizeof(*bi)),
); err != nil {
return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
}
runtime.KeepAlive(f)
// Reinterpret the alignedFileBasicInfo as a FileBasicInfo so it matches the
// public API of this module. The data may be unnecessarily aligned.
return (*FileBasicInfo)(unsafe.Pointer(bi)), nil
}
// SetFileBasicInfo sets times and attributes for a file.
func SetFileBasicInfo(f *os.File, bi *FileBasicInfo) error {
// Create an alignedFileBasicInfo based on a FileBasicInfo. The copy is
// suitable to pass to GetFileInformationByHandleEx.
biAligned := *(*alignedFileBasicInfo)(unsafe.Pointer(bi))
if err := windows.SetFileInformationByHandle(
windows.Handle(f.Fd()),
windows.FileBasicInfo,
(*byte)(unsafe.Pointer(&biAligned)),
uint32(unsafe.Sizeof(biAligned)),
); err != nil {
return &os.PathError{Op: "SetFileInformationByHandle", Path: f.Name(), Err: err}
}
runtime.KeepAlive(f)
return nil
}
// FileStandardInfo contains extended information for the file.
// FILE_STANDARD_INFO in WinBase.h
// https://docs.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-file_standard_info
type FileStandardInfo struct {
AllocationSize, EndOfFile int64
NumberOfLinks uint32
DeletePending, Directory bool
}
// GetFileStandardInfo retrieves ended information for the file.
func GetFileStandardInfo(f *os.File) (*FileStandardInfo, error) {
si := &FileStandardInfo{}
if err := windows.GetFileInformationByHandleEx(windows.Handle(f.Fd()),
windows.FileStandardInfo,
(*byte)(unsafe.Pointer(si)),
uint32(unsafe.Sizeof(*si))); err != nil {
return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
}
runtime.KeepAlive(f)
return si, nil
}
// FileIDInfo contains the volume serial number and file ID for a file. This pair should be
// unique on a system.
type FileIDInfo struct {
VolumeSerialNumber uint64
FileID [16]byte
}
// GetFileID retrieves the unique (volume, file ID) pair for a file.
func GetFileID(f *os.File) (*FileIDInfo, error) {
fileID := &FileIDInfo{}
if err := windows.GetFileInformationByHandleEx(
windows.Handle(f.Fd()),
windows.FileIdInfo,
(*byte)(unsafe.Pointer(fileID)),
uint32(unsafe.Sizeof(*fileID)),
); err != nil {
return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
}
runtime.KeepAlive(f)
return fileID, nil
}

582
vendor/github.com/Microsoft/go-winio/hvsock.go generated vendored Normal file
View File

@@ -0,0 +1,582 @@
//go:build windows
// +build windows
package winio
import (
"context"
"errors"
"fmt"
"io"
"net"
"os"
"time"
"unsafe"
"golang.org/x/sys/windows"
"github.com/Microsoft/go-winio/internal/socket"
"github.com/Microsoft/go-winio/pkg/guid"
)
const afHVSock = 34 // AF_HYPERV
// Well known Service and VM IDs
// https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/user-guide/make-integration-service#vmid-wildcards
// HvsockGUIDWildcard is the wildcard VmId for accepting connections from all partitions.
func HvsockGUIDWildcard() guid.GUID { // 00000000-0000-0000-0000-000000000000
return guid.GUID{}
}
// HvsockGUIDBroadcast is the wildcard VmId for broadcasting sends to all partitions.
func HvsockGUIDBroadcast() guid.GUID { // ffffffff-ffff-ffff-ffff-ffffffffffff
return guid.GUID{
Data1: 0xffffffff,
Data2: 0xffff,
Data3: 0xffff,
Data4: [8]uint8{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
}
}
// HvsockGUIDLoopback is the Loopback VmId for accepting connections to the same partition as the connector.
func HvsockGUIDLoopback() guid.GUID { // e0e16197-dd56-4a10-9195-5ee7a155a838
return guid.GUID{
Data1: 0xe0e16197,
Data2: 0xdd56,
Data3: 0x4a10,
Data4: [8]uint8{0x91, 0x95, 0x5e, 0xe7, 0xa1, 0x55, 0xa8, 0x38},
}
}
// HvsockGUIDSiloHost is the address of a silo's host partition:
// - The silo host of a hosted silo is the utility VM.
// - The silo host of a silo on a physical host is the physical host.
func HvsockGUIDSiloHost() guid.GUID { // 36bd0c5c-7276-4223-88ba-7d03b654c568
return guid.GUID{
Data1: 0x36bd0c5c,
Data2: 0x7276,
Data3: 0x4223,
Data4: [8]byte{0x88, 0xba, 0x7d, 0x03, 0xb6, 0x54, 0xc5, 0x68},
}
}
// HvsockGUIDChildren is the wildcard VmId for accepting connections from the connector's child partitions.
func HvsockGUIDChildren() guid.GUID { // 90db8b89-0d35-4f79-8ce9-49ea0ac8b7cd
return guid.GUID{
Data1: 0x90db8b89,
Data2: 0xd35,
Data3: 0x4f79,
Data4: [8]uint8{0x8c, 0xe9, 0x49, 0xea, 0xa, 0xc8, 0xb7, 0xcd},
}
}
// HvsockGUIDParent is the wildcard VmId for accepting connections from the connector's parent partition.
// Listening on this VmId accepts connection from:
// - Inside silos: silo host partition.
// - Inside hosted silo: host of the VM.
// - Inside VM: VM host.
// - Physical host: Not supported.
func HvsockGUIDParent() guid.GUID { // a42e7cda-d03f-480c-9cc2-a4de20abb878
return guid.GUID{
Data1: 0xa42e7cda,
Data2: 0xd03f,
Data3: 0x480c,
Data4: [8]uint8{0x9c, 0xc2, 0xa4, 0xde, 0x20, 0xab, 0xb8, 0x78},
}
}
// hvsockVsockServiceTemplate is the Service GUID used for the VSOCK protocol.
func hvsockVsockServiceTemplate() guid.GUID { // 00000000-facb-11e6-bd58-64006a7986d3
return guid.GUID{
Data2: 0xfacb,
Data3: 0x11e6,
Data4: [8]uint8{0xbd, 0x58, 0x64, 0x00, 0x6a, 0x79, 0x86, 0xd3},
}
}
// An HvsockAddr is an address for a AF_HYPERV socket.
type HvsockAddr struct {
VMID guid.GUID
ServiceID guid.GUID
}
type rawHvsockAddr struct {
Family uint16
_ uint16
VMID guid.GUID
ServiceID guid.GUID
}
var _ socket.RawSockaddr = &rawHvsockAddr{}
// Network returns the address's network name, "hvsock".
func (*HvsockAddr) Network() string {
return "hvsock"
}
func (addr *HvsockAddr) String() string {
return fmt.Sprintf("%s:%s", &addr.VMID, &addr.ServiceID)
}
// VsockServiceID returns an hvsock service ID corresponding to the specified AF_VSOCK port.
func VsockServiceID(port uint32) guid.GUID {
g := hvsockVsockServiceTemplate() // make a copy
g.Data1 = port
return g
}
func (addr *HvsockAddr) raw() rawHvsockAddr {
return rawHvsockAddr{
Family: afHVSock,
VMID: addr.VMID,
ServiceID: addr.ServiceID,
}
}
func (addr *HvsockAddr) fromRaw(raw *rawHvsockAddr) {
addr.VMID = raw.VMID
addr.ServiceID = raw.ServiceID
}
// Sockaddr returns a pointer to and the size of this struct.
//
// Implements the [socket.RawSockaddr] interface, and allows use in
// [socket.Bind] and [socket.ConnectEx].
func (r *rawHvsockAddr) Sockaddr() (unsafe.Pointer, int32, error) {
return unsafe.Pointer(r), int32(unsafe.Sizeof(rawHvsockAddr{})), nil
}
// Sockaddr interface allows use with `sockets.Bind()` and `.ConnectEx()`.
func (r *rawHvsockAddr) FromBytes(b []byte) error {
n := int(unsafe.Sizeof(rawHvsockAddr{}))
if len(b) < n {
return fmt.Errorf("got %d, want %d: %w", len(b), n, socket.ErrBufferSize)
}
copy(unsafe.Slice((*byte)(unsafe.Pointer(r)), n), b[:n])
if r.Family != afHVSock {
return fmt.Errorf("got %d, want %d: %w", r.Family, afHVSock, socket.ErrAddrFamily)
}
return nil
}
// HvsockListener is a socket listener for the AF_HYPERV address family.
type HvsockListener struct {
sock *win32File
addr HvsockAddr
}
var _ net.Listener = &HvsockListener{}
// HvsockConn is a connected socket of the AF_HYPERV address family.
type HvsockConn struct {
sock *win32File
local, remote HvsockAddr
}
var _ net.Conn = &HvsockConn{}
func newHVSocket() (*win32File, error) {
fd, err := windows.Socket(afHVSock, windows.SOCK_STREAM, 1)
if err != nil {
return nil, os.NewSyscallError("socket", err)
}
f, err := makeWin32File(fd)
if err != nil {
windows.Close(fd)
return nil, err
}
f.socket = true
return f, nil
}
// ListenHvsock listens for connections on the specified hvsock address.
func ListenHvsock(addr *HvsockAddr) (_ *HvsockListener, err error) {
l := &HvsockListener{addr: *addr}
var sock *win32File
sock, err = newHVSocket()
if err != nil {
return nil, l.opErr("listen", err)
}
defer func() {
if err != nil {
_ = sock.Close()
}
}()
sa := addr.raw()
err = socket.Bind(sock.handle, &sa)
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("socket", err))
}
err = windows.Listen(sock.handle, 16)
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("listen", err))
}
return &HvsockListener{sock: sock, addr: *addr}, nil
}
func (l *HvsockListener) opErr(op string, err error) error {
return &net.OpError{Op: op, Net: "hvsock", Addr: &l.addr, Err: err}
}
// Addr returns the listener's network address.
func (l *HvsockListener) Addr() net.Addr {
return &l.addr
}
// Accept waits for the next connection and returns it.
func (l *HvsockListener) Accept() (_ net.Conn, err error) {
sock, err := newHVSocket()
if err != nil {
return nil, l.opErr("accept", err)
}
defer func() {
if sock != nil {
sock.Close()
}
}()
c, err := l.sock.prepareIO()
if err != nil {
return nil, l.opErr("accept", err)
}
defer l.sock.wg.Done()
// AcceptEx, per documentation, requires an extra 16 bytes per address.
//
// https://docs.microsoft.com/en-us/windows/win32/api/mswsock/nf-mswsock-acceptex
const addrlen = uint32(16 + unsafe.Sizeof(rawHvsockAddr{}))
var addrbuf [addrlen * 2]byte
var bytes uint32
err = windows.AcceptEx(l.sock.handle, sock.handle, &addrbuf[0], 0 /* rxdatalen */, addrlen, addrlen, &bytes, &c.o)
if _, err = l.sock.asyncIO(c, nil, bytes, err); err != nil {
return nil, l.opErr("accept", os.NewSyscallError("acceptex", err))
}
conn := &HvsockConn{
sock: sock,
}
// The local address returned in the AcceptEx buffer is the same as the Listener socket's
// address. However, the service GUID reported by GetSockName is different from the Listeners
// socket, and is sometimes the same as the local address of the socket that dialed the
// address, with the service GUID.Data1 incremented, but othertimes is different.
// todo: does the local address matter? is the listener's address or the actual address appropriate?
conn.local.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[0])))
conn.remote.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[addrlen])))
// initialize the accepted socket and update its properties with those of the listening socket
if err = windows.Setsockopt(sock.handle,
windows.SOL_SOCKET, windows.SO_UPDATE_ACCEPT_CONTEXT,
(*byte)(unsafe.Pointer(&l.sock.handle)), int32(unsafe.Sizeof(l.sock.handle))); err != nil {
return nil, conn.opErr("accept", os.NewSyscallError("setsockopt", err))
}
sock = nil
return conn, nil
}
// Close closes the listener, causing any pending Accept calls to fail.
func (l *HvsockListener) Close() error {
return l.sock.Close()
}
// HvsockDialer configures and dials a Hyper-V Socket (ie, [HvsockConn]).
type HvsockDialer struct {
// Deadline is the time the Dial operation must connect before erroring.
Deadline time.Time
// Retries is the number of additional connects to try if the connection times out, is refused,
// or the host is unreachable
Retries uint
// RetryWait is the time to wait after a connection error to retry
RetryWait time.Duration
rt *time.Timer // redial wait timer
}
// Dial the Hyper-V socket at addr.
//
// See [HvsockDialer.Dial] for more information.
func Dial(ctx context.Context, addr *HvsockAddr) (conn *HvsockConn, err error) {
return (&HvsockDialer{}).Dial(ctx, addr)
}
// Dial attempts to connect to the Hyper-V socket at addr, and returns a connection if successful.
// Will attempt (HvsockDialer).Retries if dialing fails, waiting (HvsockDialer).RetryWait between
// retries.
//
// Dialing can be cancelled either by providing (HvsockDialer).Deadline, or cancelling ctx.
func (d *HvsockDialer) Dial(ctx context.Context, addr *HvsockAddr) (conn *HvsockConn, err error) {
op := "dial"
// create the conn early to use opErr()
conn = &HvsockConn{
remote: *addr,
}
if !d.Deadline.IsZero() {
var cancel context.CancelFunc
ctx, cancel = context.WithDeadline(ctx, d.Deadline)
defer cancel()
}
// preemptive timeout/cancellation check
if err = ctx.Err(); err != nil {
return nil, conn.opErr(op, err)
}
sock, err := newHVSocket()
if err != nil {
return nil, conn.opErr(op, err)
}
defer func() {
if sock != nil {
sock.Close()
}
}()
sa := addr.raw()
err = socket.Bind(sock.handle, &sa)
if err != nil {
return nil, conn.opErr(op, os.NewSyscallError("bind", err))
}
c, err := sock.prepareIO()
if err != nil {
return nil, conn.opErr(op, err)
}
defer sock.wg.Done()
var bytes uint32
for i := uint(0); i <= d.Retries; i++ {
err = socket.ConnectEx(
sock.handle,
&sa,
nil, // sendBuf
0, // sendDataLen
&bytes,
(*windows.Overlapped)(unsafe.Pointer(&c.o)))
_, err = sock.asyncIO(c, nil, bytes, err)
if i < d.Retries && canRedial(err) {
if err = d.redialWait(ctx); err == nil {
continue
}
}
break
}
if err != nil {
return nil, conn.opErr(op, os.NewSyscallError("connectex", err))
}
// update the connection properties, so shutdown can be used
if err = windows.Setsockopt(
sock.handle,
windows.SOL_SOCKET,
windows.SO_UPDATE_CONNECT_CONTEXT,
nil, // optvalue
0, // optlen
); err != nil {
return nil, conn.opErr(op, os.NewSyscallError("setsockopt", err))
}
// get the local name
var sal rawHvsockAddr
err = socket.GetSockName(sock.handle, &sal)
if err != nil {
return nil, conn.opErr(op, os.NewSyscallError("getsockname", err))
}
conn.local.fromRaw(&sal)
// one last check for timeout, since asyncIO doesn't check the context
if err = ctx.Err(); err != nil {
return nil, conn.opErr(op, err)
}
conn.sock = sock
sock = nil
return conn, nil
}
// redialWait waits before attempting to redial, resetting the timer as appropriate.
func (d *HvsockDialer) redialWait(ctx context.Context) (err error) {
if d.RetryWait == 0 {
return nil
}
if d.rt == nil {
d.rt = time.NewTimer(d.RetryWait)
} else {
// should already be stopped and drained
d.rt.Reset(d.RetryWait)
}
select {
case <-ctx.Done():
case <-d.rt.C:
return nil
}
// stop and drain the timer
if !d.rt.Stop() {
<-d.rt.C
}
return ctx.Err()
}
// assumes error is a plain, unwrapped windows.Errno provided by direct syscall.
func canRedial(err error) bool {
//nolint:errorlint // guaranteed to be an Errno
switch err {
case windows.WSAECONNREFUSED, windows.WSAENETUNREACH, windows.WSAETIMEDOUT,
windows.ERROR_CONNECTION_REFUSED, windows.ERROR_CONNECTION_UNAVAIL:
return true
default:
return false
}
}
func (conn *HvsockConn) opErr(op string, err error) error {
// translate from "file closed" to "socket closed"
if errors.Is(err, ErrFileClosed) {
err = socket.ErrSocketClosed
}
return &net.OpError{Op: op, Net: "hvsock", Source: &conn.local, Addr: &conn.remote, Err: err}
}
func (conn *HvsockConn) Read(b []byte) (int, error) {
c, err := conn.sock.prepareIO()
if err != nil {
return 0, conn.opErr("read", err)
}
defer conn.sock.wg.Done()
buf := windows.WSABuf{Buf: &b[0], Len: uint32(len(b))}
var flags, bytes uint32
err = windows.WSARecv(conn.sock.handle, &buf, 1, &bytes, &flags, &c.o, nil)
n, err := conn.sock.asyncIO(c, &conn.sock.readDeadline, bytes, err)
if err != nil {
var eno windows.Errno
if errors.As(err, &eno) {
err = os.NewSyscallError("wsarecv", eno)
}
return 0, conn.opErr("read", err)
} else if n == 0 {
err = io.EOF
}
return n, err
}
func (conn *HvsockConn) Write(b []byte) (int, error) {
t := 0
for len(b) != 0 {
n, err := conn.write(b)
if err != nil {
return t + n, err
}
t += n
b = b[n:]
}
return t, nil
}
func (conn *HvsockConn) write(b []byte) (int, error) {
c, err := conn.sock.prepareIO()
if err != nil {
return 0, conn.opErr("write", err)
}
defer conn.sock.wg.Done()
buf := windows.WSABuf{Buf: &b[0], Len: uint32(len(b))}
var bytes uint32
err = windows.WSASend(conn.sock.handle, &buf, 1, &bytes, 0, &c.o, nil)
n, err := conn.sock.asyncIO(c, &conn.sock.writeDeadline, bytes, err)
if err != nil {
var eno windows.Errno
if errors.As(err, &eno) {
err = os.NewSyscallError("wsasend", eno)
}
return 0, conn.opErr("write", err)
}
return n, err
}
// Close closes the socket connection, failing any pending read or write calls.
func (conn *HvsockConn) Close() error {
return conn.sock.Close()
}
func (conn *HvsockConn) IsClosed() bool {
return conn.sock.IsClosed()
}
// shutdown disables sending or receiving on a socket.
func (conn *HvsockConn) shutdown(how int) error {
if conn.IsClosed() {
return socket.ErrSocketClosed
}
err := windows.Shutdown(conn.sock.handle, how)
if err != nil {
// If the connection was closed, shutdowns fail with "not connected"
if errors.Is(err, windows.WSAENOTCONN) ||
errors.Is(err, windows.WSAESHUTDOWN) {
err = socket.ErrSocketClosed
}
return os.NewSyscallError("shutdown", err)
}
return nil
}
// CloseRead shuts down the read end of the socket, preventing future read operations.
func (conn *HvsockConn) CloseRead() error {
err := conn.shutdown(windows.SHUT_RD)
if err != nil {
return conn.opErr("closeread", err)
}
return nil
}
// CloseWrite shuts down the write end of the socket, preventing future write operations and
// notifying the other endpoint that no more data will be written.
func (conn *HvsockConn) CloseWrite() error {
err := conn.shutdown(windows.SHUT_WR)
if err != nil {
return conn.opErr("closewrite", err)
}
return nil
}
// LocalAddr returns the local address of the connection.
func (conn *HvsockConn) LocalAddr() net.Addr {
return &conn.local
}
// RemoteAddr returns the remote address of the connection.
func (conn *HvsockConn) RemoteAddr() net.Addr {
return &conn.remote
}
// SetDeadline implements the net.Conn SetDeadline method.
func (conn *HvsockConn) SetDeadline(t time.Time) error {
// todo: implement `SetDeadline` for `win32File`
if err := conn.SetReadDeadline(t); err != nil {
return fmt.Errorf("set read deadline: %w", err)
}
if err := conn.SetWriteDeadline(t); err != nil {
return fmt.Errorf("set write deadline: %w", err)
}
return nil
}
// SetReadDeadline implements the net.Conn SetReadDeadline method.
func (conn *HvsockConn) SetReadDeadline(t time.Time) error {
return conn.sock.SetReadDeadline(t)
}
// SetWriteDeadline implements the net.Conn SetWriteDeadline method.
func (conn *HvsockConn) SetWriteDeadline(t time.Time) error {
return conn.sock.SetWriteDeadline(t)
}

2
vendor/github.com/Microsoft/go-winio/internal/fs/doc.go generated vendored Normal file
View File

@@ -0,0 +1,2 @@
// This package contains Win32 filesystem functionality.
package fs

262
vendor/github.com/Microsoft/go-winio/internal/fs/fs.go generated vendored Normal file
View File

@@ -0,0 +1,262 @@
//go:build windows
package fs
import (
"golang.org/x/sys/windows"
"github.com/Microsoft/go-winio/internal/stringbuffer"
)
//go:generate go run github.com/Microsoft/go-winio/tools/mkwinsyscall -output zsyscall_windows.go fs.go
// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
//sys CreateFile(name string, access AccessMask, mode FileShareMode, sa *windows.SecurityAttributes, createmode FileCreationDisposition, attrs FileFlagOrAttribute, templatefile windows.Handle) (handle windows.Handle, err error) [failretval==windows.InvalidHandle] = CreateFileW
const NullHandle windows.Handle = 0
// AccessMask defines standard, specific, and generic rights.
//
// Used with CreateFile and NtCreateFile (and co.).
//
// Bitmask:
// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
// +---------------+---------------+-------------------------------+
// |G|G|G|G|Resvd|A| StandardRights| SpecificRights |
// |R|W|E|A| |S| | |
// +-+-------------+---------------+-------------------------------+
//
// GR Generic Read
// GW Generic Write
// GE Generic Exectue
// GA Generic All
// Resvd Reserved
// AS Access Security System
//
// https://learn.microsoft.com/en-us/windows/win32/secauthz/access-mask
//
// https://learn.microsoft.com/en-us/windows/win32/secauthz/generic-access-rights
//
// https://learn.microsoft.com/en-us/windows/win32/fileio/file-access-rights-constants
type AccessMask = windows.ACCESS_MASK
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
const (
// Not actually any.
//
// For CreateFile: "query certain metadata such as file, directory, or device attributes without accessing that file or device"
// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew#parameters
FILE_ANY_ACCESS AccessMask = 0
GENERIC_READ AccessMask = 0x8000_0000
GENERIC_WRITE AccessMask = 0x4000_0000
GENERIC_EXECUTE AccessMask = 0x2000_0000
GENERIC_ALL AccessMask = 0x1000_0000
ACCESS_SYSTEM_SECURITY AccessMask = 0x0100_0000
// Specific Object Access
// from ntioapi.h
FILE_READ_DATA AccessMask = (0x0001) // file & pipe
FILE_LIST_DIRECTORY AccessMask = (0x0001) // directory
FILE_WRITE_DATA AccessMask = (0x0002) // file & pipe
FILE_ADD_FILE AccessMask = (0x0002) // directory
FILE_APPEND_DATA AccessMask = (0x0004) // file
FILE_ADD_SUBDIRECTORY AccessMask = (0x0004) // directory
FILE_CREATE_PIPE_INSTANCE AccessMask = (0x0004) // named pipe
FILE_READ_EA AccessMask = (0x0008) // file & directory
FILE_READ_PROPERTIES AccessMask = FILE_READ_EA
FILE_WRITE_EA AccessMask = (0x0010) // file & directory
FILE_WRITE_PROPERTIES AccessMask = FILE_WRITE_EA
FILE_EXECUTE AccessMask = (0x0020) // file
FILE_TRAVERSE AccessMask = (0x0020) // directory
FILE_DELETE_CHILD AccessMask = (0x0040) // directory
FILE_READ_ATTRIBUTES AccessMask = (0x0080) // all
FILE_WRITE_ATTRIBUTES AccessMask = (0x0100) // all
FILE_ALL_ACCESS AccessMask = (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF)
FILE_GENERIC_READ AccessMask = (STANDARD_RIGHTS_READ | FILE_READ_DATA | FILE_READ_ATTRIBUTES | FILE_READ_EA | SYNCHRONIZE)
FILE_GENERIC_WRITE AccessMask = (STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE)
FILE_GENERIC_EXECUTE AccessMask = (STANDARD_RIGHTS_EXECUTE | FILE_READ_ATTRIBUTES | FILE_EXECUTE | SYNCHRONIZE)
SPECIFIC_RIGHTS_ALL AccessMask = 0x0000FFFF
// Standard Access
// from ntseapi.h
DELETE AccessMask = 0x0001_0000
READ_CONTROL AccessMask = 0x0002_0000
WRITE_DAC AccessMask = 0x0004_0000
WRITE_OWNER AccessMask = 0x0008_0000
SYNCHRONIZE AccessMask = 0x0010_0000
STANDARD_RIGHTS_REQUIRED AccessMask = 0x000F_0000
STANDARD_RIGHTS_READ AccessMask = READ_CONTROL
STANDARD_RIGHTS_WRITE AccessMask = READ_CONTROL
STANDARD_RIGHTS_EXECUTE AccessMask = READ_CONTROL
STANDARD_RIGHTS_ALL AccessMask = 0x001F_0000
)
type FileShareMode uint32
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
const (
FILE_SHARE_NONE FileShareMode = 0x00
FILE_SHARE_READ FileShareMode = 0x01
FILE_SHARE_WRITE FileShareMode = 0x02
FILE_SHARE_DELETE FileShareMode = 0x04
FILE_SHARE_VALID_FLAGS FileShareMode = 0x07
)
type FileCreationDisposition uint32
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
const (
// from winbase.h
CREATE_NEW FileCreationDisposition = 0x01
CREATE_ALWAYS FileCreationDisposition = 0x02
OPEN_EXISTING FileCreationDisposition = 0x03
OPEN_ALWAYS FileCreationDisposition = 0x04
TRUNCATE_EXISTING FileCreationDisposition = 0x05
)
// Create disposition values for NtCreate*
type NTFileCreationDisposition uint32
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
const (
// From ntioapi.h
FILE_SUPERSEDE NTFileCreationDisposition = 0x00
FILE_OPEN NTFileCreationDisposition = 0x01
FILE_CREATE NTFileCreationDisposition = 0x02
FILE_OPEN_IF NTFileCreationDisposition = 0x03
FILE_OVERWRITE NTFileCreationDisposition = 0x04
FILE_OVERWRITE_IF NTFileCreationDisposition = 0x05
FILE_MAXIMUM_DISPOSITION NTFileCreationDisposition = 0x05
)
// CreateFile and co. take flags or attributes together as one parameter.
// Define alias until we can use generics to allow both
//
// https://learn.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants
type FileFlagOrAttribute uint32
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
const (
// from winnt.h
FILE_FLAG_WRITE_THROUGH FileFlagOrAttribute = 0x8000_0000
FILE_FLAG_OVERLAPPED FileFlagOrAttribute = 0x4000_0000
FILE_FLAG_NO_BUFFERING FileFlagOrAttribute = 0x2000_0000
FILE_FLAG_RANDOM_ACCESS FileFlagOrAttribute = 0x1000_0000
FILE_FLAG_SEQUENTIAL_SCAN FileFlagOrAttribute = 0x0800_0000
FILE_FLAG_DELETE_ON_CLOSE FileFlagOrAttribute = 0x0400_0000
FILE_FLAG_BACKUP_SEMANTICS FileFlagOrAttribute = 0x0200_0000
FILE_FLAG_POSIX_SEMANTICS FileFlagOrAttribute = 0x0100_0000
FILE_FLAG_OPEN_REPARSE_POINT FileFlagOrAttribute = 0x0020_0000
FILE_FLAG_OPEN_NO_RECALL FileFlagOrAttribute = 0x0010_0000
FILE_FLAG_FIRST_PIPE_INSTANCE FileFlagOrAttribute = 0x0008_0000
)
// NtCreate* functions take a dedicated CreateOptions parameter.
//
// https://learn.microsoft.com/en-us/windows/win32/api/Winternl/nf-winternl-ntcreatefile
//
// https://learn.microsoft.com/en-us/windows/win32/devnotes/nt-create-named-pipe-file
type NTCreateOptions uint32
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
const (
// From ntioapi.h
FILE_DIRECTORY_FILE NTCreateOptions = 0x0000_0001
FILE_WRITE_THROUGH NTCreateOptions = 0x0000_0002
FILE_SEQUENTIAL_ONLY NTCreateOptions = 0x0000_0004
FILE_NO_INTERMEDIATE_BUFFERING NTCreateOptions = 0x0000_0008
FILE_SYNCHRONOUS_IO_ALERT NTCreateOptions = 0x0000_0010
FILE_SYNCHRONOUS_IO_NONALERT NTCreateOptions = 0x0000_0020
FILE_NON_DIRECTORY_FILE NTCreateOptions = 0x0000_0040
FILE_CREATE_TREE_CONNECTION NTCreateOptions = 0x0000_0080
FILE_COMPLETE_IF_OPLOCKED NTCreateOptions = 0x0000_0100
FILE_NO_EA_KNOWLEDGE NTCreateOptions = 0x0000_0200
FILE_DISABLE_TUNNELING NTCreateOptions = 0x0000_0400
FILE_RANDOM_ACCESS NTCreateOptions = 0x0000_0800
FILE_DELETE_ON_CLOSE NTCreateOptions = 0x0000_1000
FILE_OPEN_BY_FILE_ID NTCreateOptions = 0x0000_2000
FILE_OPEN_FOR_BACKUP_INTENT NTCreateOptions = 0x0000_4000
FILE_NO_COMPRESSION NTCreateOptions = 0x0000_8000
)
type FileSQSFlag = FileFlagOrAttribute
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
const (
// from winbase.h
SECURITY_ANONYMOUS FileSQSFlag = FileSQSFlag(SecurityAnonymous << 16)
SECURITY_IDENTIFICATION FileSQSFlag = FileSQSFlag(SecurityIdentification << 16)
SECURITY_IMPERSONATION FileSQSFlag = FileSQSFlag(SecurityImpersonation << 16)
SECURITY_DELEGATION FileSQSFlag = FileSQSFlag(SecurityDelegation << 16)
SECURITY_SQOS_PRESENT FileSQSFlag = 0x0010_0000
SECURITY_VALID_SQOS_FLAGS FileSQSFlag = 0x001F_0000
)
// GetFinalPathNameByHandle flags
//
// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlew#parameters
type GetFinalPathFlag uint32
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
const (
GetFinalPathDefaultFlag GetFinalPathFlag = 0x0
FILE_NAME_NORMALIZED GetFinalPathFlag = 0x0
FILE_NAME_OPENED GetFinalPathFlag = 0x8
VOLUME_NAME_DOS GetFinalPathFlag = 0x0
VOLUME_NAME_GUID GetFinalPathFlag = 0x1
VOLUME_NAME_NT GetFinalPathFlag = 0x2
VOLUME_NAME_NONE GetFinalPathFlag = 0x4
)
// getFinalPathNameByHandle facilitates calling the Windows API GetFinalPathNameByHandle
// with the given handle and flags. It transparently takes care of creating a buffer of the
// correct size for the call.
//
// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlew
func GetFinalPathNameByHandle(h windows.Handle, flags GetFinalPathFlag) (string, error) {
b := stringbuffer.NewWString()
//TODO: can loop infinitely if Win32 keeps returning the same (or a larger) n?
for {
n, err := windows.GetFinalPathNameByHandle(h, b.Pointer(), b.Cap(), uint32(flags))
if err != nil {
return "", err
}
// If the buffer wasn't large enough, n will be the total size needed (including null terminator).
// Resize and try again.
if n > b.Cap() {
b.ResizeTo(n)
continue
}
// If the buffer is large enough, n will be the size not including the null terminator.
// Convert to a Go string and return.
return b.String(), nil
}
}

12
vendor/github.com/Microsoft/go-winio/internal/fs/security.go generated vendored Normal file
View File

@@ -0,0 +1,12 @@
package fs
// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level
type SecurityImpersonationLevel int32 // C default enums underlying type is `int`, which is Go `int32`
// Impersonation levels
const (
SecurityAnonymous SecurityImpersonationLevel = 0
SecurityIdentification SecurityImpersonationLevel = 1
SecurityImpersonation SecurityImpersonationLevel = 2
SecurityDelegation SecurityImpersonationLevel = 3
)

61
vendor/github.com/Microsoft/go-winio/internal/fs/zsyscall_windows.go generated vendored Normal file
View File

@@ -0,0 +1,61 @@
//go:build windows
// Code generated by 'go generate' using "github.com/Microsoft/go-winio/tools/mkwinsyscall"; DO NOT EDIT.
package fs
import (
"syscall"
"unsafe"
"golang.org/x/sys/windows"
)
var _ unsafe.Pointer
// Do the interface allocations only once for common
// Errno values.
const (
errnoERROR_IO_PENDING = 997
)
var (
errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
errERROR_EINVAL error = syscall.EINVAL
)
// errnoErr returns common boxed Errno values, to prevent
// allocations at runtime.
func errnoErr(e syscall.Errno) error {
switch e {
case 0:
return errERROR_EINVAL
case errnoERROR_IO_PENDING:
return errERROR_IO_PENDING
}
return e
}
var (
modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
procCreateFileW = modkernel32.NewProc("CreateFileW")
)
func CreateFile(name string, access AccessMask, mode FileShareMode, sa *windows.SecurityAttributes, createmode FileCreationDisposition, attrs FileFlagOrAttribute, templatefile windows.Handle) (handle windows.Handle, err error) {
var _p0 *uint16
_p0, err = syscall.UTF16PtrFromString(name)
if err != nil {
return
}
return _CreateFile(_p0, access, mode, sa, createmode, attrs, templatefile)
}
func _CreateFile(name *uint16, access AccessMask, mode FileShareMode, sa *windows.SecurityAttributes, createmode FileCreationDisposition, attrs FileFlagOrAttribute, templatefile windows.Handle) (handle windows.Handle, err error) {
r0, _, e1 := syscall.SyscallN(procCreateFileW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(access), uintptr(mode), uintptr(unsafe.Pointer(sa)), uintptr(createmode), uintptr(attrs), uintptr(templatefile))
handle = windows.Handle(r0)
if handle == windows.InvalidHandle {
err = errnoErr(e1)
}
return
}

20
vendor/github.com/Microsoft/go-winio/internal/socket/rawaddr.go generated vendored Normal file
View File

@@ -0,0 +1,20 @@
package socket
import (
"unsafe"
)
// RawSockaddr allows structs to be used with [Bind] and [ConnectEx]. The
// struct must meet the Win32 sockaddr requirements specified here:
// https://docs.microsoft.com/en-us/windows/win32/winsock/sockaddr-2
//
// Specifically, the struct size must be least larger than an int16 (unsigned short)
// for the address family.
type RawSockaddr interface {
// Sockaddr returns a pointer to the RawSockaddr and its struct size, allowing
// for the RawSockaddr's data to be overwritten by syscalls (if necessary).
//
// It is the callers responsibility to validate that the values are valid; invalid
// pointers or size can cause a panic.
Sockaddr() (unsafe.Pointer, int32, error)
}

177
vendor/github.com/Microsoft/go-winio/internal/socket/socket.go generated vendored Normal file
View File

@@ -0,0 +1,177 @@
//go:build windows
package socket
import (
"errors"
"fmt"
"net"
"sync"
"syscall"
"unsafe"
"github.com/Microsoft/go-winio/pkg/guid"
"golang.org/x/sys/windows"
)
//go:generate go run github.com/Microsoft/go-winio/tools/mkwinsyscall -output zsyscall_windows.go socket.go
//sys getsockname(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) [failretval==socketError] = ws2_32.getsockname
//sys getpeername(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) [failretval==socketError] = ws2_32.getpeername
//sys bind(s windows.Handle, name unsafe.Pointer, namelen int32) (err error) [failretval==socketError] = ws2_32.bind
const socketError = uintptr(^uint32(0))
var (
// todo(helsaawy): create custom error types to store the desired vs actual size and addr family?
ErrBufferSize = errors.New("buffer size")
ErrAddrFamily = errors.New("address family")
ErrInvalidPointer = errors.New("invalid pointer")
ErrSocketClosed = fmt.Errorf("socket closed: %w", net.ErrClosed)
)
// todo(helsaawy): replace these with generics, ie: GetSockName[S RawSockaddr](s windows.Handle) (S, error)
// GetSockName writes the local address of socket s to the [RawSockaddr] rsa.
// If rsa is not large enough, the [windows.WSAEFAULT] is returned.
func GetSockName(s windows.Handle, rsa RawSockaddr) error {
ptr, l, err := rsa.Sockaddr()
if err != nil {
return fmt.Errorf("could not retrieve socket pointer and size: %w", err)
}
// although getsockname returns WSAEFAULT if the buffer is too small, it does not set
// &l to the correct size, so--apart from doubling the buffer repeatedly--there is no remedy
return getsockname(s, ptr, &l)
}
// GetPeerName returns the remote address the socket is connected to.
//
// See [GetSockName] for more information.
func GetPeerName(s windows.Handle, rsa RawSockaddr) error {
ptr, l, err := rsa.Sockaddr()
if err != nil {
return fmt.Errorf("could not retrieve socket pointer and size: %w", err)
}
return getpeername(s, ptr, &l)
}
func Bind(s windows.Handle, rsa RawSockaddr) (err error) {
ptr, l, err := rsa.Sockaddr()
if err != nil {
return fmt.Errorf("could not retrieve socket pointer and size: %w", err)
}
return bind(s, ptr, l)
}
// "golang.org/x/sys/windows".ConnectEx and .Bind only accept internal implementations of the
// their sockaddr interface, so they cannot be used with HvsockAddr
// Replicate functionality here from
// https://cs.opensource.google/go/x/sys/+/master:windows/syscall_windows.go
// The function pointers to `AcceptEx`, `ConnectEx` and `GetAcceptExSockaddrs` must be loaded at
// runtime via a WSAIoctl call:
// https://docs.microsoft.com/en-us/windows/win32/api/Mswsock/nc-mswsock-lpfn_connectex#remarks
type runtimeFunc struct {
id guid.GUID
once sync.Once
addr uintptr
err error
}
func (f *runtimeFunc) Load() error {
f.once.Do(func() {
var s windows.Handle
s, f.err = windows.Socket(windows.AF_INET, windows.SOCK_STREAM, windows.IPPROTO_TCP)
if f.err != nil {
return
}
defer windows.CloseHandle(s) //nolint:errcheck
var n uint32
f.err = windows.WSAIoctl(s,
windows.SIO_GET_EXTENSION_FUNCTION_POINTER,
(*byte)(unsafe.Pointer(&f.id)),
uint32(unsafe.Sizeof(f.id)),
(*byte)(unsafe.Pointer(&f.addr)),
uint32(unsafe.Sizeof(f.addr)),
&n,
nil, // overlapped
0, // completionRoutine
)
})
return f.err
}
var (
// todo: add `AcceptEx` and `GetAcceptExSockaddrs`
WSAID_CONNECTEX = guid.GUID{ //revive:disable-line:var-naming ALL_CAPS
Data1: 0x25a207b9,
Data2: 0xddf3,
Data3: 0x4660,
Data4: [8]byte{0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e},
}
connectExFunc = runtimeFunc{id: WSAID_CONNECTEX}
)
func ConnectEx(
fd windows.Handle,
rsa RawSockaddr,
sendBuf *byte,
sendDataLen uint32,
bytesSent *uint32,
overlapped *windows.Overlapped,
) error {
if err := connectExFunc.Load(); err != nil {
return fmt.Errorf("failed to load ConnectEx function pointer: %w", err)
}
ptr, n, err := rsa.Sockaddr()
if err != nil {
return err
}
return connectEx(fd, ptr, n, sendBuf, sendDataLen, bytesSent, overlapped)
}
// BOOL LpfnConnectex(
// [in] SOCKET s,
// [in] const sockaddr *name,
// [in] int namelen,
// [in, optional] PVOID lpSendBuffer,
// [in] DWORD dwSendDataLength,
// [out] LPDWORD lpdwBytesSent,
// [in] LPOVERLAPPED lpOverlapped
// )
func connectEx(
s windows.Handle,
name unsafe.Pointer,
namelen int32,
sendBuf *byte,
sendDataLen uint32,
bytesSent *uint32,
overlapped *windows.Overlapped,
) (err error) {
r1, _, e1 := syscall.SyscallN(connectExFunc.addr,
uintptr(s),
uintptr(name),
uintptr(namelen),
uintptr(unsafe.Pointer(sendBuf)),
uintptr(sendDataLen),
uintptr(unsafe.Pointer(bytesSent)),
uintptr(unsafe.Pointer(overlapped)),
)
if r1 == 0 {
if e1 != 0 {
err = error(e1)
} else {
err = syscall.EINVAL
}
}
return err
}

69
vendor/github.com/Microsoft/go-winio/internal/socket/zsyscall_windows.go generated vendored Normal file
View File

@@ -0,0 +1,69 @@
//go:build windows
// Code generated by 'go generate' using "github.com/Microsoft/go-winio/tools/mkwinsyscall"; DO NOT EDIT.
package socket
import (
"syscall"
"unsafe"
"golang.org/x/sys/windows"
)
var _ unsafe.Pointer
// Do the interface allocations only once for common
// Errno values.
const (
errnoERROR_IO_PENDING = 997
)
var (
errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
errERROR_EINVAL error = syscall.EINVAL
)
// errnoErr returns common boxed Errno values, to prevent
// allocations at runtime.
func errnoErr(e syscall.Errno) error {
switch e {
case 0:
return errERROR_EINVAL
case errnoERROR_IO_PENDING:
return errERROR_IO_PENDING
}
return e
}
var (
modws2_32 = windows.NewLazySystemDLL("ws2_32.dll")
procbind = modws2_32.NewProc("bind")
procgetpeername = modws2_32.NewProc("getpeername")
procgetsockname = modws2_32.NewProc("getsockname")
)
func bind(s windows.Handle, name unsafe.Pointer, namelen int32) (err error) {
r1, _, e1 := syscall.SyscallN(procbind.Addr(), uintptr(s), uintptr(name), uintptr(namelen))
if r1 == socketError {
err = errnoErr(e1)
}
return
}
func getpeername(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) {
r1, _, e1 := syscall.SyscallN(procgetpeername.Addr(), uintptr(s), uintptr(name), uintptr(unsafe.Pointer(namelen)))
if r1 == socketError {
err = errnoErr(e1)
}
return
}
func getsockname(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) {
r1, _, e1 := syscall.SyscallN(procgetsockname.Addr(), uintptr(s), uintptr(name), uintptr(unsafe.Pointer(namelen)))
if r1 == socketError {
err = errnoErr(e1)
}
return
}

132
vendor/github.com/Microsoft/go-winio/internal/stringbuffer/wstring.go generated vendored Normal file
View File

@@ -0,0 +1,132 @@
package stringbuffer
import (
"sync"
"unicode/utf16"
)
// TODO: worth exporting and using in mkwinsyscall?
// Uint16BufferSize is the buffer size in the pool, chosen somewhat arbitrarily to accommodate
// large path strings:
// MAX_PATH (260) + size of volume GUID prefix (49) + null terminator = 310.
const MinWStringCap = 310
// use *[]uint16 since []uint16 creates an extra allocation where the slice header
// is copied to heap and then referenced via pointer in the interface header that sync.Pool
// stores.
var pathPool = sync.Pool{ // if go1.18+ adds Pool[T], use that to store []uint16 directly
New: func() interface{} {
b := make([]uint16, MinWStringCap)
return &b
},
}
func newBuffer() []uint16 { return *(pathPool.Get().(*[]uint16)) }
// freeBuffer copies the slice header data, and puts a pointer to that in the pool.
// This avoids taking a pointer to the slice header in WString, which can be set to nil.
func freeBuffer(b []uint16) { pathPool.Put(&b) }
// WString is a wide string buffer ([]uint16) meant for storing UTF-16 encoded strings
// for interacting with Win32 APIs.
// Sizes are specified as uint32 and not int.
//
// It is not thread safe.
type WString struct {
// type-def allows casting to []uint16 directly, use struct to prevent that and allow adding fields in the future.
// raw buffer
b []uint16
}
// NewWString returns a [WString] allocated from a shared pool with an
// initial capacity of at least [MinWStringCap].
// Since the buffer may have been previously used, its contents are not guaranteed to be empty.
//
// The buffer should be freed via [WString.Free]
func NewWString() *WString {
return &WString{
b: newBuffer(),
}
}
func (b *WString) Free() {
if b.empty() {
return
}
freeBuffer(b.b)
b.b = nil
}
// ResizeTo grows the buffer to at least c and returns the new capacity, freeing the
// previous buffer back into pool.
func (b *WString) ResizeTo(c uint32) uint32 {
// already sufficient (or n is 0)
if c <= b.Cap() {
return b.Cap()
}
if c <= MinWStringCap {
c = MinWStringCap
}
// allocate at-least double buffer size, as is done in [bytes.Buffer] and other places
if c <= 2*b.Cap() {
c = 2 * b.Cap()
}
b2 := make([]uint16, c)
if !b.empty() {
copy(b2, b.b)
freeBuffer(b.b)
}
b.b = b2
return c
}
// Buffer returns the underlying []uint16 buffer.
func (b *WString) Buffer() []uint16 {
if b.empty() {
return nil
}
return b.b
}
// Pointer returns a pointer to the first uint16 in the buffer.
// If the [WString.Free] has already been called, the pointer will be nil.
func (b *WString) Pointer() *uint16 {
if b.empty() {
return nil
}
return &b.b[0]
}
// String returns the returns the UTF-8 encoding of the UTF-16 string in the buffer.
//
// It assumes that the data is null-terminated.
func (b *WString) String() string {
// Using [windows.UTF16ToString] would require importing "golang.org/x/sys/windows"
// and would make this code Windows-only, which makes no sense.
// So copy UTF16ToString code into here.
// If other windows-specific code is added, switch to [windows.UTF16ToString]
s := b.b
for i, v := range s {
if v == 0 {
s = s[:i]
break
}
}
return string(utf16.Decode(s))
}
// Cap returns the underlying buffer capacity.
func (b *WString) Cap() uint32 {
if b.empty() {
return 0
}
return b.cap()
}
func (b *WString) cap() uint32 { return uint32(cap(b.b)) }
func (b *WString) empty() bool { return b == nil || b.cap() == 0 }

586
vendor/github.com/Microsoft/go-winio/pipe.go generated vendored Normal file
View File

@@ -0,0 +1,586 @@
//go:build windows
// +build windows
package winio
import (
"context"
"errors"
"fmt"
"io"
"net"
"os"
"runtime"
"time"
"unsafe"
"golang.org/x/sys/windows"
"github.com/Microsoft/go-winio/internal/fs"
)
//sys connectNamedPipe(pipe windows.Handle, o *windows.Overlapped) (err error) = ConnectNamedPipe
//sys createNamedPipe(name string, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *windows.SecurityAttributes) (handle windows.Handle, err error) [failretval==windows.InvalidHandle] = CreateNamedPipeW
//sys disconnectNamedPipe(pipe windows.Handle) (err error) = DisconnectNamedPipe
//sys getNamedPipeInfo(pipe windows.Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) = GetNamedPipeInfo
//sys getNamedPipeHandleState(pipe windows.Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) = GetNamedPipeHandleStateW
//sys ntCreateNamedPipeFile(pipe *windows.Handle, access ntAccessMask, oa *objectAttributes, iosb *ioStatusBlock, share ntFileShareMode, disposition ntFileCreationDisposition, options ntFileOptions, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (status ntStatus) = ntdll.NtCreateNamedPipeFile
//sys rtlNtStatusToDosError(status ntStatus) (winerr error) = ntdll.RtlNtStatusToDosErrorNoTeb
//sys rtlDosPathNameToNtPathName(name *uint16, ntName *unicodeString, filePart uintptr, reserved uintptr) (status ntStatus) = ntdll.RtlDosPathNameToNtPathName_U
//sys rtlDefaultNpAcl(dacl *uintptr) (status ntStatus) = ntdll.RtlDefaultNpAcl
type PipeConn interface {
net.Conn
Disconnect() error
Flush() error
}
// type aliases for mkwinsyscall code
type (
ntAccessMask = fs.AccessMask
ntFileShareMode = fs.FileShareMode
ntFileCreationDisposition = fs.NTFileCreationDisposition
ntFileOptions = fs.NTCreateOptions
)
type ioStatusBlock struct {
Status, Information uintptr
}
// typedef struct _OBJECT_ATTRIBUTES {
// ULONG Length;
// HANDLE RootDirectory;
// PUNICODE_STRING ObjectName;
// ULONG Attributes;
// PVOID SecurityDescriptor;
// PVOID SecurityQualityOfService;
// } OBJECT_ATTRIBUTES;
//
// https://learn.microsoft.com/en-us/windows/win32/api/ntdef/ns-ntdef-_object_attributes
type objectAttributes struct {
Length uintptr
RootDirectory uintptr
ObjectName *unicodeString
Attributes uintptr
SecurityDescriptor *securityDescriptor
SecurityQoS uintptr
}
type unicodeString struct {
Length uint16
MaximumLength uint16
Buffer uintptr
}
// typedef struct _SECURITY_DESCRIPTOR {
// BYTE Revision;
// BYTE Sbz1;
// SECURITY_DESCRIPTOR_CONTROL Control;
// PSID Owner;
// PSID Group;
// PACL Sacl;
// PACL Dacl;
// } SECURITY_DESCRIPTOR, *PISECURITY_DESCRIPTOR;
//
// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-security_descriptor
type securityDescriptor struct {
Revision byte
Sbz1 byte
Control uint16
Owner uintptr
Group uintptr
Sacl uintptr //revive:disable-line:var-naming SACL, not Sacl
Dacl uintptr //revive:disable-line:var-naming DACL, not Dacl
}
type ntStatus int32
func (status ntStatus) Err() error {
if status >= 0 {
return nil
}
return rtlNtStatusToDosError(status)
}
var (
// ErrPipeListenerClosed is returned for pipe operations on listeners that have been closed.
ErrPipeListenerClosed = net.ErrClosed
errPipeWriteClosed = errors.New("pipe has been closed for write")
)
type win32Pipe struct {
*win32File
path string
}
var _ PipeConn = (*win32Pipe)(nil)
type win32MessageBytePipe struct {
win32Pipe
writeClosed bool
readEOF bool
}
type pipeAddress string
func (f *win32Pipe) LocalAddr() net.Addr {
return pipeAddress(f.path)
}
func (f *win32Pipe) RemoteAddr() net.Addr {
return pipeAddress(f.path)
}
func (f *win32Pipe) SetDeadline(t time.Time) error {
if err := f.SetReadDeadline(t); err != nil {
return err
}
return f.SetWriteDeadline(t)
}
func (f *win32Pipe) Disconnect() error {
return disconnectNamedPipe(f.win32File.handle)
}
// CloseWrite closes the write side of a message pipe in byte mode.
func (f *win32MessageBytePipe) CloseWrite() error {
if f.writeClosed {
return errPipeWriteClosed
}
err := f.win32File.Flush()
if err != nil {
return err
}
_, err = f.win32File.Write(nil)
if err != nil {
return err
}
f.writeClosed = true
return nil
}
// Write writes bytes to a message pipe in byte mode. Zero-byte writes are ignored, since
// they are used to implement CloseWrite().
func (f *win32MessageBytePipe) Write(b []byte) (int, error) {
if f.writeClosed {
return 0, errPipeWriteClosed
}
if len(b) == 0 {
return 0, nil
}
return f.win32File.Write(b)
}
// Read reads bytes from a message pipe in byte mode. A read of a zero-byte message on a message
// mode pipe will return io.EOF, as will all subsequent reads.
func (f *win32MessageBytePipe) Read(b []byte) (int, error) {
if f.readEOF {
return 0, io.EOF
}
n, err := f.win32File.Read(b)
if err == io.EOF { //nolint:errorlint
// If this was the result of a zero-byte read, then
// it is possible that the read was due to a zero-size
// message. Since we are simulating CloseWrite with a
// zero-byte message, ensure that all future Read() calls
// also return EOF.
f.readEOF = true
} else if err == windows.ERROR_MORE_DATA { //nolint:errorlint // err is Errno
// ERROR_MORE_DATA indicates that the pipe's read mode is message mode
// and the message still has more bytes. Treat this as a success, since
// this package presents all named pipes as byte streams.
err = nil
}
return n, err
}
func (pipeAddress) Network() string {
return "pipe"
}
func (s pipeAddress) String() string {
return string(s)
}
// tryDialPipe attempts to dial the pipe at `path` until `ctx` cancellation or timeout.
func tryDialPipe(ctx context.Context, path *string, access fs.AccessMask, impLevel PipeImpLevel) (windows.Handle, error) {
for {
select {
case <-ctx.Done():
return windows.Handle(0), ctx.Err()
default:
h, err := fs.CreateFile(*path,
access,
0, // mode
nil, // security attributes
fs.OPEN_EXISTING,
fs.FILE_FLAG_OVERLAPPED|fs.SECURITY_SQOS_PRESENT|fs.FileSQSFlag(impLevel),
0, // template file handle
)
if err == nil {
return h, nil
}
if err != windows.ERROR_PIPE_BUSY { //nolint:errorlint // err is Errno
return h, &os.PathError{Err: err, Op: "open", Path: *path}
}
// Wait 10 msec and try again. This is a rather simplistic
// view, as we always try each 10 milliseconds.
time.Sleep(10 * time.Millisecond)
}
}
}
// DialPipe connects to a named pipe by path, timing out if the connection
// takes longer than the specified duration. If timeout is nil, then we use
// a default timeout of 2 seconds. (We do not use WaitNamedPipe.)
func DialPipe(path string, timeout *time.Duration) (net.Conn, error) {
var absTimeout time.Time
if timeout != nil {
absTimeout = time.Now().Add(*timeout)
} else {
absTimeout = time.Now().Add(2 * time.Second)
}
ctx, cancel := context.WithDeadline(context.Background(), absTimeout)
defer cancel()
conn, err := DialPipeContext(ctx, path)
if errors.Is(err, context.DeadlineExceeded) {
return nil, ErrTimeout
}
return conn, err
}
// DialPipeContext attempts to connect to a named pipe by `path` until `ctx`
// cancellation or timeout.
func DialPipeContext(ctx context.Context, path string) (net.Conn, error) {
return DialPipeAccess(ctx, path, uint32(fs.GENERIC_READ|fs.GENERIC_WRITE))
}
// PipeImpLevel is an enumeration of impersonation levels that may be set
// when calling DialPipeAccessImpersonation.
type PipeImpLevel uint32
const (
PipeImpLevelAnonymous = PipeImpLevel(fs.SECURITY_ANONYMOUS)
PipeImpLevelIdentification = PipeImpLevel(fs.SECURITY_IDENTIFICATION)
PipeImpLevelImpersonation = PipeImpLevel(fs.SECURITY_IMPERSONATION)
PipeImpLevelDelegation = PipeImpLevel(fs.SECURITY_DELEGATION)
)
// DialPipeAccess attempts to connect to a named pipe by `path` with `access` until `ctx`
// cancellation or timeout.
func DialPipeAccess(ctx context.Context, path string, access uint32) (net.Conn, error) {
return DialPipeAccessImpLevel(ctx, path, access, PipeImpLevelAnonymous)
}
// DialPipeAccessImpLevel attempts to connect to a named pipe by `path` with
// `access` at `impLevel` until `ctx` cancellation or timeout. The other
// DialPipe* implementations use PipeImpLevelAnonymous.
func DialPipeAccessImpLevel(ctx context.Context, path string, access uint32, impLevel PipeImpLevel) (net.Conn, error) {
var err error
var h windows.Handle
h, err = tryDialPipe(ctx, &path, fs.AccessMask(access), impLevel)
if err != nil {
return nil, err
}
var flags uint32
err = getNamedPipeInfo(h, &flags, nil, nil, nil)
if err != nil {
return nil, err
}
f, err := makeWin32File(h)
if err != nil {
windows.Close(h)
return nil, err
}
// If the pipe is in message mode, return a message byte pipe, which
// supports CloseWrite().
if flags&windows.PIPE_TYPE_MESSAGE != 0 {
return &win32MessageBytePipe{
win32Pipe: win32Pipe{win32File: f, path: path},
}, nil
}
return &win32Pipe{win32File: f, path: path}, nil
}
type acceptResponse struct {
f *win32File
err error
}
type win32PipeListener struct {
firstHandle windows.Handle
path string
config PipeConfig
acceptCh chan (chan acceptResponse)
closeCh chan int
doneCh chan int
}
func makeServerPipeHandle(path string, sd []byte, c *PipeConfig, first bool) (windows.Handle, error) {
path16, err := windows.UTF16FromString(path)
if err != nil {
return 0, &os.PathError{Op: "open", Path: path, Err: err}
}
var oa objectAttributes
oa.Length = unsafe.Sizeof(oa)
var ntPath unicodeString
if err := rtlDosPathNameToNtPathName(&path16[0],
&ntPath,
0,
0,
).Err(); err != nil {
return 0, &os.PathError{Op: "open", Path: path, Err: err}
}
defer windows.LocalFree(windows.Handle(ntPath.Buffer)) //nolint:errcheck
oa.ObjectName = &ntPath
oa.Attributes = windows.OBJ_CASE_INSENSITIVE
// The security descriptor is only needed for the first pipe.
if first {
if sd != nil {
//todo: does `sdb` need to be allocated on the heap, or can go allocate it?
l := uint32(len(sd))
sdb, err := windows.LocalAlloc(0, l)
if err != nil {
return 0, fmt.Errorf("LocalAlloc for security descriptor with of length %d: %w", l, err)
}
defer windows.LocalFree(windows.Handle(sdb)) //nolint:errcheck
copy((*[0xffff]byte)(unsafe.Pointer(sdb))[:], sd)
oa.SecurityDescriptor = (*securityDescriptor)(unsafe.Pointer(sdb))
} else {
// Construct the default named pipe security descriptor.
var dacl uintptr
if err := rtlDefaultNpAcl(&dacl).Err(); err != nil {
return 0, fmt.Errorf("getting default named pipe ACL: %w", err)
}
defer windows.LocalFree(windows.Handle(dacl)) //nolint:errcheck
sdb := &securityDescriptor{
Revision: 1,
Control: windows.SE_DACL_PRESENT,
Dacl: dacl,
}
oa.SecurityDescriptor = sdb
}
}
typ := uint32(windows.FILE_PIPE_REJECT_REMOTE_CLIENTS)
if c.MessageMode {
typ |= windows.FILE_PIPE_MESSAGE_TYPE
}
disposition := fs.FILE_OPEN
access := fs.GENERIC_READ | fs.GENERIC_WRITE | fs.SYNCHRONIZE
if first {
disposition = fs.FILE_CREATE
// By not asking for read or write access, the named pipe file system
// will put this pipe into an initially disconnected state, blocking
// client connections until the next call with first == false.
access = fs.SYNCHRONIZE
}
timeout := int64(-50 * 10000) // 50ms
var (
h windows.Handle
iosb ioStatusBlock
)
err = ntCreateNamedPipeFile(&h,
access,
&oa,
&iosb,
fs.FILE_SHARE_READ|fs.FILE_SHARE_WRITE,
disposition,
0,
typ,
0,
0,
0xffffffff,
uint32(c.InputBufferSize),
uint32(c.OutputBufferSize),
&timeout).Err()
if err != nil {
return 0, &os.PathError{Op: "open", Path: path, Err: err}
}
runtime.KeepAlive(ntPath)
return h, nil
}
func (l *win32PipeListener) makeServerPipe() (*win32File, error) {
h, err := makeServerPipeHandle(l.path, nil, &l.config, false)
if err != nil {
return nil, err
}
f, err := makeWin32File(h)
if err != nil {
windows.Close(h)
return nil, err
}
return f, nil
}
func (l *win32PipeListener) makeConnectedServerPipe() (*win32File, error) {
p, err := l.makeServerPipe()
if err != nil {
return nil, err
}
// Wait for the client to connect.
ch := make(chan error)
go func(p *win32File) {
ch <- connectPipe(p)
}(p)
select {
case err = <-ch:
if err != nil {
p.Close()
p = nil
}
case <-l.closeCh:
// Abort the connect request by closing the handle.
p.Close()
p = nil
err = <-ch
if err == nil || err == ErrFileClosed { //nolint:errorlint // err is Errno
err = ErrPipeListenerClosed
}
}
return p, err
}
func (l *win32PipeListener) listenerRoutine() {
closed := false
for !closed {
select {
case <-l.closeCh:
closed = true
case responseCh := <-l.acceptCh:
var (
p *win32File
err error
)
for {
p, err = l.makeConnectedServerPipe()
// If the connection was immediately closed by the client, try
// again.
if err != windows.ERROR_NO_DATA { //nolint:errorlint // err is Errno
break
}
}
responseCh <- acceptResponse{p, err}
closed = err == ErrPipeListenerClosed //nolint:errorlint // err is Errno
}
}
windows.Close(l.firstHandle)
l.firstHandle = 0
// Notify Close() and Accept() callers that the handle has been closed.
close(l.doneCh)
}
// PipeConfig contain configuration for the pipe listener.
type PipeConfig struct {
// SecurityDescriptor contains a Windows security descriptor in SDDL format.
SecurityDescriptor string
// MessageMode determines whether the pipe is in byte or message mode. In either
// case the pipe is read in byte mode by default. The only practical difference in
// this implementation is that CloseWrite() is only supported for message mode pipes;
// CloseWrite() is implemented as a zero-byte write, but zero-byte writes are only
// transferred to the reader (and returned as io.EOF in this implementation)
// when the pipe is in message mode.
MessageMode bool
// InputBufferSize specifies the size of the input buffer, in bytes.
InputBufferSize int32
// OutputBufferSize specifies the size of the output buffer, in bytes.
OutputBufferSize int32
}
// ListenPipe creates a listener on a Windows named pipe path, e.g. \\.\pipe\mypipe.
// The pipe must not already exist.
func ListenPipe(path string, c *PipeConfig) (net.Listener, error) {
var (
sd []byte
err error
)
if c == nil {
c = &PipeConfig{}
}
if c.SecurityDescriptor != "" {
sd, err = SddlToSecurityDescriptor(c.SecurityDescriptor)
if err != nil {
return nil, err
}
}
h, err := makeServerPipeHandle(path, sd, c, true)
if err != nil {
return nil, err
}
l := &win32PipeListener{
firstHandle: h,
path: path,
config: *c,
acceptCh: make(chan (chan acceptResponse)),
closeCh: make(chan int),
doneCh: make(chan int),
}
go l.listenerRoutine()
return l, nil
}
func connectPipe(p *win32File) error {
c, err := p.prepareIO()
if err != nil {
return err
}
defer p.wg.Done()
err = connectNamedPipe(p.handle, &c.o)
_, err = p.asyncIO(c, nil, 0, err)
if err != nil && err != windows.ERROR_PIPE_CONNECTED { //nolint:errorlint // err is Errno
return err
}
return nil
}
func (l *win32PipeListener) Accept() (net.Conn, error) {
ch := make(chan acceptResponse)
select {
case l.acceptCh <- ch:
response := <-ch
err := response.err
if err != nil {
return nil, err
}
if l.config.MessageMode {
return &win32MessageBytePipe{
win32Pipe: win32Pipe{win32File: response.f, path: l.path},
}, nil
}
return &win32Pipe{win32File: response.f, path: l.path}, nil
case <-l.doneCh:
return nil, ErrPipeListenerClosed
}
}
func (l *win32PipeListener) Close() error {
select {
case l.closeCh <- 1:
<-l.doneCh
case <-l.doneCh:
}
return nil
}
func (l *win32PipeListener) Addr() net.Addr {
return pipeAddress(l.path)
}

232
vendor/github.com/Microsoft/go-winio/pkg/guid/guid.go generated vendored Normal file
View File

@@ -0,0 +1,232 @@
// Package guid provides a GUID type. The backing structure for a GUID is
// identical to that used by the golang.org/x/sys/windows GUID type.
// There are two main binary encodings used for a GUID, the big-endian encoding,
// and the Windows (mixed-endian) encoding. See here for details:
// https://en.wikipedia.org/wiki/Universally_unique_identifier#Encoding
package guid
import (
"crypto/rand"
"crypto/sha1" //nolint:gosec // not used for secure application
"encoding"
"encoding/binary"
"fmt"
"strconv"
)
//go:generate go run golang.org/x/tools/cmd/stringer -type=Variant -trimprefix=Variant -linecomment
// Variant specifies which GUID variant (or "type") of the GUID. It determines
// how the entirety of the rest of the GUID is interpreted.
type Variant uint8
// The variants specified by RFC 4122 section 4.1.1.
const (
// VariantUnknown specifies a GUID variant which does not conform to one of
// the variant encodings specified in RFC 4122.
VariantUnknown Variant = iota
VariantNCS
VariantRFC4122 // RFC 4122
VariantMicrosoft
VariantFuture
)
// Version specifies how the bits in the GUID were generated. For instance, a
// version 4 GUID is randomly generated, and a version 5 is generated from the
// hash of an input string.
type Version uint8
func (v Version) String() string {
return strconv.FormatUint(uint64(v), 10)
}
var _ = (encoding.TextMarshaler)(GUID{})
var _ = (encoding.TextUnmarshaler)(&GUID{})
// NewV4 returns a new version 4 (pseudorandom) GUID, as defined by RFC 4122.
func NewV4() (GUID, error) {
var b [16]byte
if _, err := rand.Read(b[:]); err != nil {
return GUID{}, err
}
g := FromArray(b)
g.setVersion(4) // Version 4 means randomly generated.
g.setVariant(VariantRFC4122)
return g, nil
}
// NewV5 returns a new version 5 (generated from a string via SHA-1 hashing)
// GUID, as defined by RFC 4122. The RFC is unclear on the encoding of the name,
// and the sample code treats it as a series of bytes, so we do the same here.
//
// Some implementations, such as those found on Windows, treat the name as a
// big-endian UTF16 stream of bytes. If that is desired, the string can be
// encoded as such before being passed to this function.
func NewV5(namespace GUID, name []byte) (GUID, error) {
b := sha1.New() //nolint:gosec // not used for secure application
namespaceBytes := namespace.ToArray()
b.Write(namespaceBytes[:])
b.Write(name)
a := [16]byte{}
copy(a[:], b.Sum(nil))
g := FromArray(a)
g.setVersion(5) // Version 5 means generated from a string.
g.setVariant(VariantRFC4122)
return g, nil
}
func fromArray(b [16]byte, order binary.ByteOrder) GUID {
var g GUID
g.Data1 = order.Uint32(b[0:4])
g.Data2 = order.Uint16(b[4:6])
g.Data3 = order.Uint16(b[6:8])
copy(g.Data4[:], b[8:16])
return g
}
func (g GUID) toArray(order binary.ByteOrder) [16]byte {
b := [16]byte{}
order.PutUint32(b[0:4], g.Data1)
order.PutUint16(b[4:6], g.Data2)
order.PutUint16(b[6:8], g.Data3)
copy(b[8:16], g.Data4[:])
return b
}
// FromArray constructs a GUID from a big-endian encoding array of 16 bytes.
func FromArray(b [16]byte) GUID {
return fromArray(b, binary.BigEndian)
}
// ToArray returns an array of 16 bytes representing the GUID in big-endian
// encoding.
func (g GUID) ToArray() [16]byte {
return g.toArray(binary.BigEndian)
}
// FromWindowsArray constructs a GUID from a Windows encoding array of bytes.
func FromWindowsArray(b [16]byte) GUID {
return fromArray(b, binary.LittleEndian)
}
// ToWindowsArray returns an array of 16 bytes representing the GUID in Windows
// encoding.
func (g GUID) ToWindowsArray() [16]byte {
return g.toArray(binary.LittleEndian)
}
func (g GUID) String() string {
return fmt.Sprintf(
"%08x-%04x-%04x-%04x-%012x",
g.Data1,
g.Data2,
g.Data3,
g.Data4[:2],
g.Data4[2:])
}
// FromString parses a string containing a GUID and returns the GUID. The only
// format currently supported is the `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`
// format.
func FromString(s string) (GUID, error) {
if len(s) != 36 {
return GUID{}, fmt.Errorf("invalid GUID %q", s)
}
if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
return GUID{}, fmt.Errorf("invalid GUID %q", s)
}
var g GUID
data1, err := strconv.ParseUint(s[0:8], 16, 32)
if err != nil {
return GUID{}, fmt.Errorf("invalid GUID %q", s)
}
g.Data1 = uint32(data1)
data2, err := strconv.ParseUint(s[9:13], 16, 16)
if err != nil {
return GUID{}, fmt.Errorf("invalid GUID %q", s)
}
g.Data2 = uint16(data2)
data3, err := strconv.ParseUint(s[14:18], 16, 16)
if err != nil {
return GUID{}, fmt.Errorf("invalid GUID %q", s)
}
g.Data3 = uint16(data3)
for i, x := range []int{19, 21, 24, 26, 28, 30, 32, 34} {
v, err := strconv.ParseUint(s[x:x+2], 16, 8)
if err != nil {
return GUID{}, fmt.Errorf("invalid GUID %q", s)
}
g.Data4[i] = uint8(v)
}
return g, nil
}
func (g *GUID) setVariant(v Variant) {
d := g.Data4[0]
switch v {
case VariantNCS:
d = (d & 0x7f)
case VariantRFC4122:
d = (d & 0x3f) | 0x80
case VariantMicrosoft:
d = (d & 0x1f) | 0xc0
case VariantFuture:
d = (d & 0x0f) | 0xe0
case VariantUnknown:
fallthrough
default:
panic(fmt.Sprintf("invalid variant: %d", v))
}
g.Data4[0] = d
}
// Variant returns the GUID variant, as defined in RFC 4122.
func (g GUID) Variant() Variant {
b := g.Data4[0]
if b&0x80 == 0 {
return VariantNCS
} else if b&0xc0 == 0x80 {
return VariantRFC4122
} else if b&0xe0 == 0xc0 {
return VariantMicrosoft
} else if b&0xe0 == 0xe0 {
return VariantFuture
}
return VariantUnknown
}
func (g *GUID) setVersion(v Version) {
g.Data3 = (g.Data3 & 0x0fff) | (uint16(v) << 12)
}
// Version returns the GUID version, as defined in RFC 4122.
func (g GUID) Version() Version {
return Version((g.Data3 & 0xF000) >> 12)
}
// MarshalText returns the textual representation of the GUID.
func (g GUID) MarshalText() ([]byte, error) {
return []byte(g.String()), nil
}
// UnmarshalText takes the textual representation of a GUID, and unmarhals it
// into this GUID.
func (g *GUID) UnmarshalText(text []byte) error {
g2, err := FromString(string(text))
if err != nil {
return err
}
*g = g2
return nil
}

16
vendor/github.com/Microsoft/go-winio/pkg/guid/guid_nonwindows.go generated vendored Normal file
View File

@@ -0,0 +1,16 @@
//go:build !windows
// +build !windows
package guid
// GUID represents a GUID/UUID. It has the same structure as
// golang.org/x/sys/windows.GUID so that it can be used with functions expecting
// that type. It is defined as its own type as that is only available to builds
// targeted at `windows`. The representation matches that used by native Windows
// code.
type GUID struct {
Data1 uint32
Data2 uint16
Data3 uint16
Data4 [8]byte
}

13
vendor/github.com/Microsoft/go-winio/pkg/guid/guid_windows.go generated vendored Normal file
View File

@@ -0,0 +1,13 @@
//go:build windows
// +build windows
package guid
import "golang.org/x/sys/windows"
// GUID represents a GUID/UUID. It has the same structure as
// golang.org/x/sys/windows.GUID so that it can be used with functions expecting
// that type. It is defined as its own type so that stringification and
// marshaling can be supported. The representation matches that used by native
// Windows code.
type GUID windows.GUID

27
vendor/github.com/Microsoft/go-winio/pkg/guid/variant_string.go generated vendored Normal file
View File

@@ -0,0 +1,27 @@
// Code generated by "stringer -type=Variant -trimprefix=Variant -linecomment"; DO NOT EDIT.
package guid
import "strconv"
func _() {
// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
var x [1]struct{}
_ = x[VariantUnknown-0]
_ = x[VariantNCS-1]
_ = x[VariantRFC4122-2]
_ = x[VariantMicrosoft-3]
_ = x[VariantFuture-4]
}
const _Variant_name = "UnknownNCSRFC 4122MicrosoftFuture"
var _Variant_index = [...]uint8{0, 7, 10, 18, 27, 33}
func (i Variant) String() string {
if i >= Variant(len(_Variant_index)-1) {
return "Variant(" + strconv.FormatInt(int64(i), 10) + ")"
}
return _Variant_name[_Variant_index[i]:_Variant_index[i+1]]
}

196
vendor/github.com/Microsoft/go-winio/privilege.go generated vendored Normal file
View File

@@ -0,0 +1,196 @@
//go:build windows
// +build windows
package winio
import (
"bytes"
"encoding/binary"
"fmt"
"runtime"
"sync"
"unicode/utf16"
"golang.org/x/sys/windows"
)
//sys adjustTokenPrivileges(token windows.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) [true] = advapi32.AdjustTokenPrivileges
//sys impersonateSelf(level uint32) (err error) = advapi32.ImpersonateSelf
//sys revertToSelf() (err error) = advapi32.RevertToSelf
//sys openThreadToken(thread windows.Handle, accessMask uint32, openAsSelf bool, token *windows.Token) (err error) = advapi32.OpenThreadToken
//sys getCurrentThread() (h windows.Handle) = GetCurrentThread
//sys lookupPrivilegeValue(systemName string, name string, luid *uint64) (err error) = advapi32.LookupPrivilegeValueW
//sys lookupPrivilegeName(systemName string, luid *uint64, buffer *uint16, size *uint32) (err error) = advapi32.LookupPrivilegeNameW
//sys lookupPrivilegeDisplayName(systemName string, name *uint16, buffer *uint16, size *uint32, languageId *uint32) (err error) = advapi32.LookupPrivilegeDisplayNameW
const (
//revive:disable-next-line:var-naming ALL_CAPS
SE_PRIVILEGE_ENABLED = windows.SE_PRIVILEGE_ENABLED
//revive:disable-next-line:var-naming ALL_CAPS
ERROR_NOT_ALL_ASSIGNED windows.Errno = windows.ERROR_NOT_ALL_ASSIGNED
SeBackupPrivilege = "SeBackupPrivilege"
SeRestorePrivilege = "SeRestorePrivilege"
SeSecurityPrivilege = "SeSecurityPrivilege"
)
var (
privNames = make(map[string]uint64)
privNameMutex sync.Mutex
)
// PrivilegeError represents an error enabling privileges.
type PrivilegeError struct {
privileges []uint64
}
func (e *PrivilegeError) Error() string {
s := "Could not enable privilege "
if len(e.privileges) > 1 {
s = "Could not enable privileges "
}
for i, p := range e.privileges {
if i != 0 {
s += ", "
}
s += `"`
s += getPrivilegeName(p)
s += `"`
}
return s
}
// RunWithPrivilege enables a single privilege for a function call.
func RunWithPrivilege(name string, fn func() error) error {
return RunWithPrivileges([]string{name}, fn)
}
// RunWithPrivileges enables privileges for a function call.
func RunWithPrivileges(names []string, fn func() error) error {
privileges, err := mapPrivileges(names)
if err != nil {
return err
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
token, err := newThreadToken()
if err != nil {
return err
}
defer releaseThreadToken(token)
err = adjustPrivileges(token, privileges, SE_PRIVILEGE_ENABLED)
if err != nil {
return err
}
return fn()
}
func mapPrivileges(names []string) ([]uint64, error) {
privileges := make([]uint64, 0, len(names))
privNameMutex.Lock()
defer privNameMutex.Unlock()
for _, name := range names {
p, ok := privNames[name]
if !ok {
err := lookupPrivilegeValue("", name, &p)
if err != nil {
return nil, err
}
privNames[name] = p
}
privileges = append(privileges, p)
}
return privileges, nil
}
// EnableProcessPrivileges enables privileges globally for the process.
func EnableProcessPrivileges(names []string) error {
return enableDisableProcessPrivilege(names, SE_PRIVILEGE_ENABLED)
}
// DisableProcessPrivileges disables privileges globally for the process.
func DisableProcessPrivileges(names []string) error {
return enableDisableProcessPrivilege(names, 0)
}
func enableDisableProcessPrivilege(names []string, action uint32) error {
privileges, err := mapPrivileges(names)
if err != nil {
return err
}
p := windows.CurrentProcess()
var token windows.Token
err = windows.OpenProcessToken(p, windows.TOKEN_ADJUST_PRIVILEGES|windows.TOKEN_QUERY, &token)
if err != nil {
return err
}
defer token.Close()
return adjustPrivileges(token, privileges, action)
}
func adjustPrivileges(token windows.Token, privileges []uint64, action uint32) error {
var b bytes.Buffer
_ = binary.Write(&b, binary.LittleEndian, uint32(len(privileges)))
for _, p := range privileges {
_ = binary.Write(&b, binary.LittleEndian, p)
_ = binary.Write(&b, binary.LittleEndian, action)
}
prevState := make([]byte, b.Len())
reqSize := uint32(0)
success, err := adjustTokenPrivileges(token, false, &b.Bytes()[0], uint32(len(prevState)), &prevState[0], &reqSize)
if !success {
return err
}
if err == ERROR_NOT_ALL_ASSIGNED { //nolint:errorlint // err is Errno
return &PrivilegeError{privileges}
}
return nil
}
func getPrivilegeName(luid uint64) string {
var nameBuffer [256]uint16
bufSize := uint32(len(nameBuffer))
err := lookupPrivilegeName("", &luid, &nameBuffer[0], &bufSize)
if err != nil {
return fmt.Sprintf("<unknown privilege %d>", luid)
}
var displayNameBuffer [256]uint16
displayBufSize := uint32(len(displayNameBuffer))
var langID uint32
err = lookupPrivilegeDisplayName("", &nameBuffer[0], &displayNameBuffer[0], &displayBufSize, &langID)
if err != nil {
return fmt.Sprintf("<unknown privilege %s>", string(utf16.Decode(nameBuffer[:bufSize])))
}
return string(utf16.Decode(displayNameBuffer[:displayBufSize]))
}
func newThreadToken() (windows.Token, error) {
err := impersonateSelf(windows.SecurityImpersonation)
if err != nil {
return 0, err
}
var token windows.Token
err = openThreadToken(getCurrentThread(), windows.TOKEN_ADJUST_PRIVILEGES|windows.TOKEN_QUERY, false, &token)
if err != nil {
rerr := revertToSelf()
if rerr != nil {
panic(rerr)
}
return 0, err
}
return token, nil
}
func releaseThreadToken(h windows.Token) {
err := revertToSelf()
if err != nil {
panic(err)
}
h.Close()
}

131
vendor/github.com/Microsoft/go-winio/reparse.go generated vendored Normal file
View File

@@ -0,0 +1,131 @@
//go:build windows
// +build windows
package winio
import (
"bytes"
"encoding/binary"
"fmt"
"strings"
"unicode/utf16"
"unsafe"
)
const (
reparseTagMountPoint = 0xA0000003
reparseTagSymlink = 0xA000000C
)
type reparseDataBuffer struct {
ReparseTag uint32
ReparseDataLength uint16
Reserved uint16
SubstituteNameOffset uint16
SubstituteNameLength uint16
PrintNameOffset uint16
PrintNameLength uint16
}
// ReparsePoint describes a Win32 symlink or mount point.
type ReparsePoint struct {
Target string
IsMountPoint bool
}
// UnsupportedReparsePointError is returned when trying to decode a non-symlink or
// mount point reparse point.
type UnsupportedReparsePointError struct {
Tag uint32
}
func (e *UnsupportedReparsePointError) Error() string {
return fmt.Sprintf("unsupported reparse point %x", e.Tag)
}
// DecodeReparsePoint decodes a Win32 REPARSE_DATA_BUFFER structure containing either a symlink
// or a mount point.
func DecodeReparsePoint(b []byte) (*ReparsePoint, error) {
tag := binary.LittleEndian.Uint32(b[0:4])
return DecodeReparsePointData(tag, b[8:])
}
func DecodeReparsePointData(tag uint32, b []byte) (*ReparsePoint, error) {
isMountPoint := false
switch tag {
case reparseTagMountPoint:
isMountPoint = true
case reparseTagSymlink:
default:
return nil, &UnsupportedReparsePointError{tag}
}
nameOffset := 8 + binary.LittleEndian.Uint16(b[4:6])
if !isMountPoint {
nameOffset += 4
}
nameLength := binary.LittleEndian.Uint16(b[6:8])
name := make([]uint16, nameLength/2)
err := binary.Read(bytes.NewReader(b[nameOffset:nameOffset+nameLength]), binary.LittleEndian, &name)
if err != nil {
return nil, err
}
return &ReparsePoint{string(utf16.Decode(name)), isMountPoint}, nil
}
func isDriveLetter(c byte) bool {
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
}
// EncodeReparsePoint encodes a Win32 REPARSE_DATA_BUFFER structure describing a symlink or
// mount point.
func EncodeReparsePoint(rp *ReparsePoint) []byte {
// Generate an NT path and determine if this is a relative path.
var ntTarget string
relative := false
if strings.HasPrefix(rp.Target, `\\?\`) {
ntTarget = `\??\` + rp.Target[4:]
} else if strings.HasPrefix(rp.Target, `\\`) {
ntTarget = `\??\UNC\` + rp.Target[2:]
} else if len(rp.Target) >= 2 && isDriveLetter(rp.Target[0]) && rp.Target[1] == ':' {
ntTarget = `\??\` + rp.Target
} else {
ntTarget = rp.Target
relative = true
}
// The paths must be NUL-terminated even though they are counted strings.
target16 := utf16.Encode([]rune(rp.Target + "\x00"))
ntTarget16 := utf16.Encode([]rune(ntTarget + "\x00"))
size := int(unsafe.Sizeof(reparseDataBuffer{})) - 8
size += len(ntTarget16)*2 + len(target16)*2
tag := uint32(reparseTagMountPoint)
if !rp.IsMountPoint {
tag = reparseTagSymlink
size += 4 // Add room for symlink flags
}
data := reparseDataBuffer{
ReparseTag: tag,
ReparseDataLength: uint16(size),
SubstituteNameOffset: 0,
SubstituteNameLength: uint16((len(ntTarget16) - 1) * 2),
PrintNameOffset: uint16(len(ntTarget16) * 2),
PrintNameLength: uint16((len(target16) - 1) * 2),
}
var b bytes.Buffer
_ = binary.Write(&b, binary.LittleEndian, &data)
if !rp.IsMountPoint {
flags := uint32(0)
if relative {
flags |= 1
}
_ = binary.Write(&b, binary.LittleEndian, flags)
}
_ = binary.Write(&b, binary.LittleEndian, ntTarget16)
_ = binary.Write(&b, binary.LittleEndian, target16)
return b.Bytes()
}

133
vendor/github.com/Microsoft/go-winio/sd.go generated vendored Normal file
View File

@@ -0,0 +1,133 @@
//go:build windows
// +build windows
package winio
import (
"errors"
"fmt"
"unsafe"
"golang.org/x/sys/windows"
)
//sys lookupAccountName(systemName *uint16, accountName string, sid *byte, sidSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) = advapi32.LookupAccountNameW
//sys lookupAccountSid(systemName *uint16, sid *byte, name *uint16, nameSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) = advapi32.LookupAccountSidW
//sys convertSidToStringSid(sid *byte, str **uint16) (err error) = advapi32.ConvertSidToStringSidW
//sys convertStringSidToSid(str *uint16, sid **byte) (err error) = advapi32.ConvertStringSidToSidW
type AccountLookupError struct {
Name string
Err error
}
func (e *AccountLookupError) Error() string {
if e.Name == "" {
return "lookup account: empty account name specified"
}
var s string
switch {
case errors.Is(e.Err, windows.ERROR_INVALID_SID):
s = "the security ID structure is invalid"
case errors.Is(e.Err, windows.ERROR_NONE_MAPPED):
s = "not found"
default:
s = e.Err.Error()
}
return "lookup account " + e.Name + ": " + s
}
func (e *AccountLookupError) Unwrap() error { return e.Err }
type SddlConversionError struct {
Sddl string
Err error
}
func (e *SddlConversionError) Error() string {
return "convert " + e.Sddl + ": " + e.Err.Error()
}
func (e *SddlConversionError) Unwrap() error { return e.Err }
// LookupSidByName looks up the SID of an account by name
//
//revive:disable-next-line:var-naming SID, not Sid
func LookupSidByName(name string) (sid string, err error) {
if name == "" {
return "", &AccountLookupError{name, windows.ERROR_NONE_MAPPED}
}
var sidSize, sidNameUse, refDomainSize uint32
err = lookupAccountName(nil, name, nil, &sidSize, nil, &refDomainSize, &sidNameUse)
if err != nil && err != windows.ERROR_INSUFFICIENT_BUFFER { //nolint:errorlint // err is Errno
return "", &AccountLookupError{name, err}
}
sidBuffer := make([]byte, sidSize)
refDomainBuffer := make([]uint16, refDomainSize)
err = lookupAccountName(nil, name, &sidBuffer[0], &sidSize, &refDomainBuffer[0], &refDomainSize, &sidNameUse)
if err != nil {
return "", &AccountLookupError{name, err}
}
var strBuffer *uint16
err = convertSidToStringSid(&sidBuffer[0], &strBuffer)
if err != nil {
return "", &AccountLookupError{name, err}
}
sid = windows.UTF16ToString((*[0xffff]uint16)(unsafe.Pointer(strBuffer))[:])
_, _ = windows.LocalFree(windows.Handle(unsafe.Pointer(strBuffer)))
return sid, nil
}
// LookupNameBySid looks up the name of an account by SID
//
//revive:disable-next-line:var-naming SID, not Sid
func LookupNameBySid(sid string) (name string, err error) {
if sid == "" {
return "", &AccountLookupError{sid, windows.ERROR_NONE_MAPPED}
}
sidBuffer, err := windows.UTF16PtrFromString(sid)
if err != nil {
return "", &AccountLookupError{sid, err}
}
var sidPtr *byte
if err = convertStringSidToSid(sidBuffer, &sidPtr); err != nil {
return "", &AccountLookupError{sid, err}
}
defer windows.LocalFree(windows.Handle(unsafe.Pointer(sidPtr))) //nolint:errcheck
var nameSize, refDomainSize, sidNameUse uint32
err = lookupAccountSid(nil, sidPtr, nil, &nameSize, nil, &refDomainSize, &sidNameUse)
if err != nil && err != windows.ERROR_INSUFFICIENT_BUFFER { //nolint:errorlint // err is Errno
return "", &AccountLookupError{sid, err}
}
nameBuffer := make([]uint16, nameSize)
refDomainBuffer := make([]uint16, refDomainSize)
err = lookupAccountSid(nil, sidPtr, &nameBuffer[0], &nameSize, &refDomainBuffer[0], &refDomainSize, &sidNameUse)
if err != nil {
return "", &AccountLookupError{sid, err}
}
name = windows.UTF16ToString(nameBuffer)
return name, nil
}
func SddlToSecurityDescriptor(sddl string) ([]byte, error) {
sd, err := windows.SecurityDescriptorFromString(sddl)
if err != nil {
return nil, &SddlConversionError{Sddl: sddl, Err: err}
}
b := unsafe.Slice((*byte)(unsafe.Pointer(sd)), sd.Length())
return b, nil
}
func SecurityDescriptorToSddl(sd []byte) (string, error) {
if l := int(unsafe.Sizeof(windows.SECURITY_DESCRIPTOR{})); len(sd) < l {
return "", fmt.Errorf("SecurityDescriptor (%d) smaller than expected (%d): %w", len(sd), l, windows.ERROR_INCORRECT_SIZE)
}
s := (*windows.SECURITY_DESCRIPTOR)(unsafe.Pointer(&sd[0]))
return s.String(), nil
}

5
vendor/github.com/Microsoft/go-winio/syscall.go generated vendored Normal file
View File

@@ -0,0 +1,5 @@
//go:build windows
package winio
//go:generate go run github.com/Microsoft/go-winio/tools/mkwinsyscall -output zsyscall_windows.go ./*.go

378
vendor/github.com/Microsoft/go-winio/zsyscall_windows.go generated vendored Normal file
View File

@@ -0,0 +1,378 @@
//go:build windows
// Code generated by 'go generate' using "github.com/Microsoft/go-winio/tools/mkwinsyscall"; DO NOT EDIT.
package winio
import (
"syscall"
"unsafe"
"golang.org/x/sys/windows"
)
var _ unsafe.Pointer
// Do the interface allocations only once for common
// Errno values.
const (
errnoERROR_IO_PENDING = 997
)
var (
errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
errERROR_EINVAL error = syscall.EINVAL
)
// errnoErr returns common boxed Errno values, to prevent
// allocations at runtime.
func errnoErr(e syscall.Errno) error {
switch e {
case 0:
return errERROR_EINVAL
case errnoERROR_IO_PENDING:
return errERROR_IO_PENDING
}
return e
}
var (
modadvapi32 = windows.NewLazySystemDLL("advapi32.dll")
modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
modntdll = windows.NewLazySystemDLL("ntdll.dll")
modws2_32 = windows.NewLazySystemDLL("ws2_32.dll")
procAdjustTokenPrivileges = modadvapi32.NewProc("AdjustTokenPrivileges")
procConvertSidToStringSidW = modadvapi32.NewProc("ConvertSidToStringSidW")
procConvertStringSidToSidW = modadvapi32.NewProc("ConvertStringSidToSidW")
procImpersonateSelf = modadvapi32.NewProc("ImpersonateSelf")
procLookupAccountNameW = modadvapi32.NewProc("LookupAccountNameW")
procLookupAccountSidW = modadvapi32.NewProc("LookupAccountSidW")
procLookupPrivilegeDisplayNameW = modadvapi32.NewProc("LookupPrivilegeDisplayNameW")
procLookupPrivilegeNameW = modadvapi32.NewProc("LookupPrivilegeNameW")
procLookupPrivilegeValueW = modadvapi32.NewProc("LookupPrivilegeValueW")
procOpenThreadToken = modadvapi32.NewProc("OpenThreadToken")
procRevertToSelf = modadvapi32.NewProc("RevertToSelf")
procBackupRead = modkernel32.NewProc("BackupRead")
procBackupWrite = modkernel32.NewProc("BackupWrite")
procCancelIoEx = modkernel32.NewProc("CancelIoEx")
procConnectNamedPipe = modkernel32.NewProc("ConnectNamedPipe")
procCreateIoCompletionPort = modkernel32.NewProc("CreateIoCompletionPort")
procCreateNamedPipeW = modkernel32.NewProc("CreateNamedPipeW")
procDisconnectNamedPipe = modkernel32.NewProc("DisconnectNamedPipe")
procGetCurrentThread = modkernel32.NewProc("GetCurrentThread")
procGetNamedPipeHandleStateW = modkernel32.NewProc("GetNamedPipeHandleStateW")
procGetNamedPipeInfo = modkernel32.NewProc("GetNamedPipeInfo")
procGetQueuedCompletionStatus = modkernel32.NewProc("GetQueuedCompletionStatus")
procSetFileCompletionNotificationModes = modkernel32.NewProc("SetFileCompletionNotificationModes")
procNtCreateNamedPipeFile = modntdll.NewProc("NtCreateNamedPipeFile")
procRtlDefaultNpAcl = modntdll.NewProc("RtlDefaultNpAcl")
procRtlDosPathNameToNtPathName_U = modntdll.NewProc("RtlDosPathNameToNtPathName_U")
procRtlNtStatusToDosErrorNoTeb = modntdll.NewProc("RtlNtStatusToDosErrorNoTeb")
procWSAGetOverlappedResult = modws2_32.NewProc("WSAGetOverlappedResult")
)
func adjustTokenPrivileges(token windows.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) {
var _p0 uint32
if releaseAll {
_p0 = 1
}
r0, _, e1 := syscall.SyscallN(procAdjustTokenPrivileges.Addr(), uintptr(token), uintptr(_p0), uintptr(unsafe.Pointer(input)), uintptr(outputSize), uintptr(unsafe.Pointer(output)), uintptr(unsafe.Pointer(requiredSize)))
success = r0 != 0
if true {
err = errnoErr(e1)
}
return
}
func convertSidToStringSid(sid *byte, str **uint16) (err error) {
r1, _, e1 := syscall.SyscallN(procConvertSidToStringSidW.Addr(), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(str)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func convertStringSidToSid(str *uint16, sid **byte) (err error) {
r1, _, e1 := syscall.SyscallN(procConvertStringSidToSidW.Addr(), uintptr(unsafe.Pointer(str)), uintptr(unsafe.Pointer(sid)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func impersonateSelf(level uint32) (err error) {
r1, _, e1 := syscall.SyscallN(procImpersonateSelf.Addr(), uintptr(level))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func lookupAccountName(systemName *uint16, accountName string, sid *byte, sidSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) {
var _p0 *uint16
_p0, err = syscall.UTF16PtrFromString(accountName)
if err != nil {
return
}
return _lookupAccountName(systemName, _p0, sid, sidSize, refDomain, refDomainSize, sidNameUse)
}
func _lookupAccountName(systemName *uint16, accountName *uint16, sid *byte, sidSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) {
r1, _, e1 := syscall.SyscallN(procLookupAccountNameW.Addr(), uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(accountName)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(sidSize)), uintptr(unsafe.Pointer(refDomain)), uintptr(unsafe.Pointer(refDomainSize)), uintptr(unsafe.Pointer(sidNameUse)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func lookupAccountSid(systemName *uint16, sid *byte, name *uint16, nameSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) {
r1, _, e1 := syscall.SyscallN(procLookupAccountSidW.Addr(), uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(nameSize)), uintptr(unsafe.Pointer(refDomain)), uintptr(unsafe.Pointer(refDomainSize)), uintptr(unsafe.Pointer(sidNameUse)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func lookupPrivilegeDisplayName(systemName string, name *uint16, buffer *uint16, size *uint32, languageId *uint32) (err error) {
var _p0 *uint16
_p0, err = syscall.UTF16PtrFromString(systemName)
if err != nil {
return
}
return _lookupPrivilegeDisplayName(_p0, name, buffer, size, languageId)
}
func _lookupPrivilegeDisplayName(systemName *uint16, name *uint16, buffer *uint16, size *uint32, languageId *uint32) (err error) {
r1, _, e1 := syscall.SyscallN(procLookupPrivilegeDisplayNameW.Addr(), uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(buffer)), uintptr(unsafe.Pointer(size)), uintptr(unsafe.Pointer(languageId)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func lookupPrivilegeName(systemName string, luid *uint64, buffer *uint16, size *uint32) (err error) {
var _p0 *uint16
_p0, err = syscall.UTF16PtrFromString(systemName)
if err != nil {
return
}
return _lookupPrivilegeName(_p0, luid, buffer, size)
}
func _lookupPrivilegeName(systemName *uint16, luid *uint64, buffer *uint16, size *uint32) (err error) {
r1, _, e1 := syscall.SyscallN(procLookupPrivilegeNameW.Addr(), uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(luid)), uintptr(unsafe.Pointer(buffer)), uintptr(unsafe.Pointer(size)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func lookupPrivilegeValue(systemName string, name string, luid *uint64) (err error) {
var _p0 *uint16
_p0, err = syscall.UTF16PtrFromString(systemName)
if err != nil {
return
}
var _p1 *uint16
_p1, err = syscall.UTF16PtrFromString(name)
if err != nil {
return
}
return _lookupPrivilegeValue(_p0, _p1, luid)
}
func _lookupPrivilegeValue(systemName *uint16, name *uint16, luid *uint64) (err error) {
r1, _, e1 := syscall.SyscallN(procLookupPrivilegeValueW.Addr(), uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(luid)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func openThreadToken(thread windows.Handle, accessMask uint32, openAsSelf bool, token *windows.Token) (err error) {
var _p0 uint32
if openAsSelf {
_p0 = 1
}
r1, _, e1 := syscall.SyscallN(procOpenThreadToken.Addr(), uintptr(thread), uintptr(accessMask), uintptr(_p0), uintptr(unsafe.Pointer(token)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func revertToSelf() (err error) {
r1, _, e1 := syscall.SyscallN(procRevertToSelf.Addr())
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func backupRead(h windows.Handle, b []byte, bytesRead *uint32, abort bool, processSecurity bool, context *uintptr) (err error) {
var _p0 *byte
if len(b) > 0 {
_p0 = &b[0]
}
var _p1 uint32
if abort {
_p1 = 1
}
var _p2 uint32
if processSecurity {
_p2 = 1
}
r1, _, e1 := syscall.SyscallN(procBackupRead.Addr(), uintptr(h), uintptr(unsafe.Pointer(_p0)), uintptr(len(b)), uintptr(unsafe.Pointer(bytesRead)), uintptr(_p1), uintptr(_p2), uintptr(unsafe.Pointer(context)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func backupWrite(h windows.Handle, b []byte, bytesWritten *uint32, abort bool, processSecurity bool, context *uintptr) (err error) {
var _p0 *byte
if len(b) > 0 {
_p0 = &b[0]
}
var _p1 uint32
if abort {
_p1 = 1
}
var _p2 uint32
if processSecurity {
_p2 = 1
}
r1, _, e1 := syscall.SyscallN(procBackupWrite.Addr(), uintptr(h), uintptr(unsafe.Pointer(_p0)), uintptr(len(b)), uintptr(unsafe.Pointer(bytesWritten)), uintptr(_p1), uintptr(_p2), uintptr(unsafe.Pointer(context)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func cancelIoEx(file windows.Handle, o *windows.Overlapped) (err error) {
r1, _, e1 := syscall.SyscallN(procCancelIoEx.Addr(), uintptr(file), uintptr(unsafe.Pointer(o)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func connectNamedPipe(pipe windows.Handle, o *windows.Overlapped) (err error) {
r1, _, e1 := syscall.SyscallN(procConnectNamedPipe.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(o)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func createIoCompletionPort(file windows.Handle, port windows.Handle, key uintptr, threadCount uint32) (newport windows.Handle, err error) {
r0, _, e1 := syscall.SyscallN(procCreateIoCompletionPort.Addr(), uintptr(file), uintptr(port), uintptr(key), uintptr(threadCount))
newport = windows.Handle(r0)
if newport == 0 {
err = errnoErr(e1)
}
return
}
func createNamedPipe(name string, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *windows.SecurityAttributes) (handle windows.Handle, err error) {
var _p0 *uint16
_p0, err = syscall.UTF16PtrFromString(name)
if err != nil {
return
}
return _createNamedPipe(_p0, flags, pipeMode, maxInstances, outSize, inSize, defaultTimeout, sa)
}
func _createNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *windows.SecurityAttributes) (handle windows.Handle, err error) {
r0, _, e1 := syscall.SyscallN(procCreateNamedPipeW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(pipeMode), uintptr(maxInstances), uintptr(outSize), uintptr(inSize), uintptr(defaultTimeout), uintptr(unsafe.Pointer(sa)))
handle = windows.Handle(r0)
if handle == windows.InvalidHandle {
err = errnoErr(e1)
}
return
}
func disconnectNamedPipe(pipe windows.Handle) (err error) {
r1, _, e1 := syscall.SyscallN(procDisconnectNamedPipe.Addr(), uintptr(pipe))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func getCurrentThread() (h windows.Handle) {
r0, _, _ := syscall.SyscallN(procGetCurrentThread.Addr())
h = windows.Handle(r0)
return
}
func getNamedPipeHandleState(pipe windows.Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) {
r1, _, e1 := syscall.SyscallN(procGetNamedPipeHandleStateW.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(curInstances)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)), uintptr(unsafe.Pointer(userName)), uintptr(maxUserNameSize))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func getNamedPipeInfo(pipe windows.Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) {
r1, _, e1 := syscall.SyscallN(procGetNamedPipeInfo.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(outSize)), uintptr(unsafe.Pointer(inSize)), uintptr(unsafe.Pointer(maxInstances)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func getQueuedCompletionStatus(port windows.Handle, bytes *uint32, key *uintptr, o **ioOperation, timeout uint32) (err error) {
r1, _, e1 := syscall.SyscallN(procGetQueuedCompletionStatus.Addr(), uintptr(port), uintptr(unsafe.Pointer(bytes)), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(o)), uintptr(timeout))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func setFileCompletionNotificationModes(h windows.Handle, flags uint8) (err error) {
r1, _, e1 := syscall.SyscallN(procSetFileCompletionNotificationModes.Addr(), uintptr(h), uintptr(flags))
if r1 == 0 {
err = errnoErr(e1)
}
return
}
func ntCreateNamedPipeFile(pipe *windows.Handle, access ntAccessMask, oa *objectAttributes, iosb *ioStatusBlock, share ntFileShareMode, disposition ntFileCreationDisposition, options ntFileOptions, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (status ntStatus) {
r0, _, _ := syscall.SyscallN(procNtCreateNamedPipeFile.Addr(), uintptr(unsafe.Pointer(pipe)), uintptr(access), uintptr(unsafe.Pointer(oa)), uintptr(unsafe.Pointer(iosb)), uintptr(share), uintptr(disposition), uintptr(options), uintptr(typ), uintptr(readMode), uintptr(completionMode), uintptr(maxInstances), uintptr(inboundQuota), uintptr(outputQuota), uintptr(unsafe.Pointer(timeout)))
status = ntStatus(r0)
return
}
func rtlDefaultNpAcl(dacl *uintptr) (status ntStatus) {
r0, _, _ := syscall.SyscallN(procRtlDefaultNpAcl.Addr(), uintptr(unsafe.Pointer(dacl)))
status = ntStatus(r0)
return
}
func rtlDosPathNameToNtPathName(name *uint16, ntName *unicodeString, filePart uintptr, reserved uintptr) (status ntStatus) {
r0, _, _ := syscall.SyscallN(procRtlDosPathNameToNtPathName_U.Addr(), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(ntName)), uintptr(filePart), uintptr(reserved))
status = ntStatus(r0)
return
}
func rtlNtStatusToDosError(status ntStatus) (winerr error) {
r0, _, _ := syscall.SyscallN(procRtlNtStatusToDosErrorNoTeb.Addr(), uintptr(status))
if r0 != 0 {
winerr = syscall.Errno(r0)
}
return
}
func wsaGetOverlappedResult(h windows.Handle, o *windows.Overlapped, bytes *uint32, wait bool, flags *uint32) (err error) {
var _p0 uint32
if wait {
_p0 = 1
}
r1, _, e1 := syscall.SyscallN(procWSAGetOverlappedResult.Addr(), uintptr(h), uintptr(unsafe.Pointer(o)), uintptr(unsafe.Pointer(bytes)), uintptr(_p0), uintptr(unsafe.Pointer(flags)))
if r1 == 0 {
err = errnoErr(e1)
}
return
}

27
vendor/github.com/bep/debounce/.gitignore generated vendored Normal file
View File

@@ -0,0 +1,27 @@
# Compiled Object files, Static and Dynamic libs (Shared Objects)
*.o
*.a
*.so
# Folders
_obj
_test
# Architecture specific extensions/prefixes
*.[568vq]
[568vq].out
*.cgo1.go
*.cgo2.c
_cgo_defun.c
_cgo_gotypes.go
_cgo_export.*
_testmain.go
*.exe
*.test
*.prof
cover.out
nohup.out

21
vendor/github.com/bep/debounce/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 2016 Bjørn Erik Pedersen
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

35
vendor/github.com/bep/debounce/README.md generated vendored Normal file
View File

@@ -0,0 +1,35 @@
# Go Debounce
[![Tests on Linux, MacOS and Windows](https://github.com/bep/debounce/workflows/Test/badge.svg)](https://github.com/bep/debounce/actions?query=workflow:Test)
[![GoDoc](https://godoc.org/github.com/bep/debounce?status.svg)](https://godoc.org/github.com/bep/debounce)
[![Go Report Card](https://goreportcard.com/badge/github.com/bep/debounce)](https://goreportcard.com/report/github.com/bep/debounce)
[![codecov](https://codecov.io/gh/bep/debounce/branch/master/graph/badge.svg)](https://codecov.io/gh/bep/debounce)
[![Release](https://img.shields.io/github/release/bep/debounce.svg?style=flat-square)](https://github.com/bep/debounce/releases/latest)
## Example
```go
func ExampleNew() {
var counter uint64
f := func() {
atomic.AddUint64(&counter, 1)
}
debounced := debounce.New(100 * time.Millisecond)
for i := 0; i < 3; i++ {
for j := 0; j < 10; j++ {
debounced(f)
}
time.Sleep(200 * time.Millisecond)
}
c := int(atomic.LoadUint64(&counter))
fmt.Println("Counter is", c)
// Output: Counter is 3
}
```

43
vendor/github.com/bep/debounce/debounce.go generated vendored Normal file
View File

@@ -0,0 +1,43 @@
// Copyright © 2019 Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>.
//
// Use of this source code is governed by an MIT-style
// license that can be found in the LICENSE file.
// Package debounce provides a debouncer func. The most typical use case would be
// the user typing a text into a form; the UI needs an update, but let's wait for
// a break.
package debounce
import (
"sync"
"time"
)
// New returns a debounced function that takes another functions as its argument.
// This function will be called when the debounced function stops being called
// for the given duration.
// The debounced function can be invoked with different functions, if needed,
// the last one will win.
func New(after time.Duration) func(f func()) {
d := &debouncer{after: after}
return func(f func()) {
d.add(f)
}
}
type debouncer struct {
mu sync.Mutex
after time.Duration
timer *time.Timer
}
func (d *debouncer) add(f func()) {
d.mu.Lock()
defer d.mu.Unlock()
if d.timer != nil {
d.timer.Stop()
}
d.timer = time.AfterFunc(d.after, f)
}

8
vendor/github.com/go-ole/go-ole/.travis.yml generated vendored Normal file
View File

@@ -0,0 +1,8 @@
language: go
sudo: false
go:
- 1.9.x
- 1.10.x
- 1.11.x
- tip

49
vendor/github.com/go-ole/go-ole/ChangeLog.md generated vendored Normal file
View File

@@ -0,0 +1,49 @@
# Version 1.x.x
* **Add more test cases and reference new test COM server project.** (Placeholder for future additions)
# Version 1.2.0-alphaX
**Minimum supported version is now Go 1.4. Go 1.1 support is deprecated, but should still build.**
* Added CI configuration for Travis-CI and AppVeyor.
* Added test InterfaceID and ClassID for the COM Test Server project.
* Added more inline documentation (#83).
* Added IEnumVARIANT implementation (#88).
* Added IEnumVARIANT test cases (#99, #100, #101).
* Added support for retrieving `time.Time` from VARIANT (#92).
* Added test case for IUnknown (#64).
* Added test case for IDispatch (#64).
* Added test cases for scalar variants (#64, #76).
# Version 1.1.1
* Fixes for Linux build.
* Fixes for Windows build.
# Version 1.1.0
The change to provide building on all platforms is a new feature. The increase in minor version reflects that and allows those who wish to stay on 1.0.x to continue to do so. Support for 1.0.x will be limited to bug fixes.
* Move GUID out of variables.go into its own file to make new documentation available.
* Move OleError out of ole.go into its own file to make new documentation available.
* Add documentation to utility functions.
* Add documentation to variant receiver functions.
* Add documentation to ole structures.
* Make variant available to other systems outside of Windows.
* Make OLE structures available to other systems outside of Windows.
## New Features
* Library should now be built on all platforms supported by Go. Library will NOOP on any platform that is not Windows.
* More functions are now documented and available on godoc.org.
# Version 1.0.1
1. Fix package references from repository location change.
# Version 1.0.0
This version is stable enough for use. The COM API is still incomplete, but provides enough functionality for accessing COM servers using IDispatch interface.
There is no changelog for this version. Check commits for history.

21
vendor/github.com/go-ole/go-ole/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright © 2013-2017 Yasuhiro Matsumoto, <mattn.jp@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the “Software”), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

46
vendor/github.com/go-ole/go-ole/README.md generated vendored Normal file
View File

@@ -0,0 +1,46 @@
# Go OLE
[![Build status](https://ci.appveyor.com/api/projects/status/qr0u2sf7q43us9fj?svg=true)](https://ci.appveyor.com/project/jacobsantos/go-ole-jgs28)
[![Build Status](https://travis-ci.org/go-ole/go-ole.svg?branch=master)](https://travis-ci.org/go-ole/go-ole)
[![GoDoc](https://godoc.org/github.com/go-ole/go-ole?status.svg)](https://godoc.org/github.com/go-ole/go-ole)
Go bindings for Windows COM using shared libraries instead of cgo.
By Yasuhiro Matsumoto.
## Install
To experiment with go-ole, you can just compile and run the example program:
```
go get github.com/go-ole/go-ole
cd /path/to/go-ole/
go test
cd /path/to/go-ole/example/excel
go run excel.go
```
## Continuous Integration
Continuous integration configuration has been added for both Travis-CI and AppVeyor. You will have to add these to your own account for your fork in order for it to run.
**Travis-CI**
Travis-CI was added to check builds on Linux to ensure that `go get` works when cross building. Currently, Travis-CI is not used to test cross-building, but this may be changed in the future. It is also not currently possible to test the library on Linux, since COM API is specific to Windows and it is not currently possible to run a COM server on Linux or even connect to a remote COM server.
**AppVeyor**
AppVeyor is used to build on Windows using the (in-development) test COM server. It is currently only used to test the build and ensure that the code works on Windows. It will be used to register a COM server and then run the test cases based on the test COM server.
The tests currently do run and do pass and this should be maintained with commits.
## Versioning
Go OLE uses [semantic versioning](http://semver.org) for version numbers, which is similar to the version contract of the Go language. Which means that the major version will always maintain backwards compatibility with minor versions. Minor versions will only add new additions and changes. Fixes will always be in patch.
This contract should allow you to upgrade to new minor and patch versions without breakage or modifications to your existing code. Leave a ticket, if there is breakage, so that it could be fixed.
## LICENSE
Under the MIT License: http://mattn.mit-license.org/2013

Some files were not shown because too many files have changed in this diff Show More