25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(plugins): carry plugin file handle ids as uuid strings
Jinpy4f0f69131b77
diff --git a/apps/desktop/src/components/plugins/PluginWorkbenchHost.spec.ts b/apps/desktop/src/components/plugins/PluginWorkbenchHost.spec.tsindex c86b8882fc..0403cec228 100644--- a/apps/desktop/src/components/plugins/PluginWorkbenchHost.spec.ts+++ b/apps/desktop/src/components/plugins/PluginWorkbenchHost.spec.ts@@ -148,7 +148,8 @@ describe("PluginWorkbenchHost initialization", () => {it("claims OS drops over its iframe and forwards opened handles to the plugin", async () => {const { frame, postMessage } = await mountHost();const elementFromPoint = vi.spyOn(document, "elementFromPoint").mockReturnValue(frame);- mocks.openPluginLocalFile.mockResolvedValue({ handleId: 7, name: "a.txt", size: 3, contentType: "text/plain", write: false });+ // The Rust registry hands out uuid strings; the `t` prefix stays opaque.+ mocks.openPluginLocalFile.mockResolvedValue({ handleId: "0d9f6d26-9e0e-4b1f-8f9a-2b6d3c5a7e81", name: "a.txt", size: 3, contentType: "text/plain", write: false });const claimed = !document.dispatchEvent(new CustomEvent("dbx:tauri-file-drop", {@@ -160,7 +161,7 @@ describe("PluginWorkbenchHost initialization", () => {expect(claimed).toBe(true);await vi.waitFor(() => {const posted = postMessage.mock.calls.map(([message]) => message as Record<string, unknown>);- expect(posted.some((message) => message.type === "filedrop" && (message.files as Array<Record<string, unknown>>)?.some((file) => file.handleId === "t7" && file.name === "a.txt"))).toBe(true);+ expect(posted.some((message) => message.type === "filedrop" && (message.files as Array<Record<string, unknown>>)?.some((file) => file.handleId === "t0d9f6d26-9e0e-4b1f-8f9a-2b6d3c5a7e81" && file.name === "a.txt"))).toBe(true);});expect(mocks.openPluginLocalFile).toHaveBeenCalledWith("sample", "/tmp/a.txt", false);elementFromPoint.mockRestore();diff --git a/apps/desktop/src/components/plugins/PluginWorkbenchHost.vue b/apps/desktop/src/components/plugins/PluginWorkbenchHost.vueindex 55bd305455..a3dd3f6c00 100644--- a/apps/desktop/src/components/plugins/PluginWorkbenchHost.vue+++ b/apps/desktop/src/components/plugins/PluginWorkbenchHost.vue@@ -60,15 +60,17 @@ let loadGeneration = 0;// --- Plugin file-transfer bridge (native dialogs + OS file drops) ---------// The sandboxed iframe cannot reach local files, so handles live here: Tauri-// handles wrap the plugin_file registry in Rust (`t<n>` ids); the web host-// keeps File objects and in-memory save buffers (`w<n>` ids). Only paths that-// came from a native dialog or an OS drop reach plugin_file_open — never a-// plugin-supplied string.+// handles wrap the plugin_file registry in Rust (`t<uuid>` ids); the web host+// keeps File objects and in-memory save buffers (`w<n>` ids). Handle ids are+// opaque strings end to end — never run them through Number(): ids above+// Number.MAX_SAFE_INTEGER silently round, and the registry then rejects every+// read with "unknown plugin file handle". Only paths that came from a native+// dialog or an OS drop reach plugin_file_open — never a plugin-supplied string.let webFileSequence = 0;const webPickedFiles = new Map<string, File>();const webSaveBuffers = new Map<string, { name: string; contentType: string; chunks: Map<number, Uint8Array> }>();-const openTauriHandles = new Set<number>();+const openTauriHandles = new Set<string>();const tauriHandlePrefix = "t";const webHandlePrefix = "w";@@ -81,9 +83,9 @@ function encodeBytesBase64(bytes: Uint8Array): string {return btoa(binary);}-function parseHandleId(handleId: string): { source: "tauri" | "web"; numericId: number } {- if (handleId.startsWith(tauriHandlePrefix)) return { source: "tauri", numericId: Number(handleId.slice(tauriHandlePrefix.length)) };- if (handleId.startsWith(webHandlePrefix)) return { source: "web", numericId: Number(handleId.slice(webHandlePrefix.length)) };+function parseHandleId(handleId: string): { source: "tauri" | "web"; rawId: string } {+ if (handleId.startsWith(tauriHandlePrefix)) return { source: "tauri", rawId: handleId.slice(tauriHandlePrefix.length) };+ if (handleId.startsWith(webHandlePrefix)) return { source: "web", rawId: handleId.slice(webHandlePrefix.length) };throw new Error("Unknown file handle");}@@ -149,7 +151,7 @@ async function readPluginFileChunkById(pluginId: string, handleId: string, offseconst parsed = parseHandleId(handleId);if (parsed.source === "tauri") {const { readPluginLocalFileChunk } = await tauriFileApi();- return readPluginLocalFileChunk(pluginId, parsed.numericId, offset, length);+ return readPluginLocalFileChunk(pluginId, parsed.rawId, offset, length);}const file = webPickedFiles.get(handleId);if (!file) throw new Error("Unknown file handle");@@ -217,7 +219,7 @@ async function writePluginFileChunkById(pluginId: string, handleId: string, offsconst parsed = parseHandleId(handleId);if (parsed.source === "tauri") {const { writePluginLocalFileChunk } = await tauriFileApi();- return writePluginLocalFileChunk(pluginId, parsed.numericId, offset, encodeBytesBase64(bytes));+ return writePluginLocalFileChunk(pluginId, parsed.rawId, offset, encodeBytesBase64(bytes));}const buffer = webSaveBuffers.get(handleId);if (!buffer) throw new Error("Unknown file handle");@@ -229,8 +231,8 @@ async function finishPluginFileSave(pluginId: string, handleId: string): Promiseconst parsed = parseHandleId(handleId);if (parsed.source === "tauri") {const { closePluginLocalFile } = await tauriFileApi();- openTauriHandles.delete(parsed.numericId);- await closePluginLocalFile(pluginId, parsed.numericId);+ openTauriHandles.delete(parsed.rawId);+ await closePluginLocalFile(pluginId, parsed.rawId);return;}const buffer = webSaveBuffers.get(handleId);@@ -256,8 +258,8 @@ async function closePluginFileHandleById(pluginId: string, handleId: string): Prconst parsed = parseHandleId(handleId);if (parsed.source === "tauri") {const { closePluginLocalFile } = await tauriFileApi();- openTauriHandles.delete(parsed.numericId);- await closePluginLocalFile(pluginId, parsed.numericId);+ openTauriHandles.delete(parsed.rawId);+ await closePluginLocalFile(pluginId, parsed.rawId);return;}webPickedFiles.delete(handleId);diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.tsindex eceea980e8..3126827a36 100644--- a/apps/desktop/src/lib/backend/http.ts+++ b/apps/desktop/src/lib/backend/http.ts@@ -5181,15 +5181,15 @@ export async function openPluginLocalFile(_pluginId: string, _path: string, _writhrow new Error("Plugin local file access is not available in the web backend");}-export async function readPluginLocalFileChunk(_pluginId: string, _handleId: number, _offset: number, _length?: number): Promise<PluginLocalFileChunk> {+export async function readPluginLocalFileChunk(_pluginId: string, _handleId: string, _offset: number, _length?: number): Promise<PluginLocalFileChunk> {throw new Error("Plugin local file access is not available in the web backend");}-export async function writePluginLocalFileChunk(_pluginId: string, _handleId: number, _offset: number, _dataBase64: string): Promise<PluginLocalFileWriteResult> {+export async function writePluginLocalFileChunk(_pluginId: string, _handleId: string, _offset: number, _dataBase64: string): Promise<PluginLocalFileWriteResult> {throw new Error("Plugin local file access is not available in the web backend");}-export async function closePluginLocalFile(_pluginId: string, _handleId: number): Promise<void> {+export async function closePluginLocalFile(_pluginId: string, _handleId: string): Promise<void> {throw new Error("Plugin local file access is not available in the web backend");}diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.tsindex 54a27f65ca..531f3a2bf9 100644--- a/apps/desktop/src/lib/backend/tauri.ts+++ b/apps/desktop/src/lib/backend/tauri.ts@@ -2462,7 +2462,8 @@ export async function sendPluginBinary(pluginId: string, channel: string, dataBa}export interface PluginLocalFileHandle {- handleId: number;+ /** Opaque uuid string from the Rust registry — never a number (JS doubles lose precision above 2^53). */+ handleId: string;name: string;size: number;contentType: string;@@ -2484,15 +2485,15 @@ export async function openPluginLocalFile(pluginId: string, path: string, write:return invoke("plugin_file_open", { pluginId, path, write });}-export async function readPluginLocalFileChunk(pluginId: string, handleId: number, offset: number, length?: number): Promise<PluginLocalFileChunk> {+export async function readPluginLocalFileChunk(pluginId: string, handleId: string, offset: number, length?: number): Promise<PluginLocalFileChunk> {return invoke("plugin_file_read", { pluginId, handleId, offset, length });}-export async function writePluginLocalFileChunk(pluginId: string, handleId: number, offset: number, dataBase64: string): Promise<PluginLocalFileWriteResult> {+export async function writePluginLocalFileChunk(pluginId: string, handleId: string, offset: number, dataBase64: string): Promise<PluginLocalFileWriteResult> {return invoke("plugin_file_write", { pluginId, handleId, offset, dataBase64 });}-export async function closePluginLocalFile(pluginId: string, handleId: number): Promise<void> {+export async function closePluginLocalFile(pluginId: string, handleId: string): Promise<void> {return invoke("plugin_file_close", { pluginId, handleId });}diff --git a/src-tauri/src/commands/plugin_file.rs b/src-tauri/src/commands/plugin_file.rsindex 5f085ea204..8d50ba9981 100644--- a/src-tauri/src/commands/plugin_file.rs+++ b/src-tauri/src/commands/plugin_file.rs@@ -40,7 +40,7 @@ struct OpenFile {#[derive(Default)]pub struct PluginFileState {- handles: Mutex<HashMap<u64, OpenFile>>,+ handles: Mutex<HashMap<String, OpenFile>>,}impl PluginFileState {@@ -52,7 +52,12 @@ impl PluginFileState {#[derive(Debug, Serialize)]#[serde(rename_all = "camelCase")]pub struct PluginFileHandle {- handle_id: u64,+ /// Opaque handle id, carried as a UUID string on the wire — the same+ /// convention as `downloadId`. It must never be a JSON number: ids are+ /// parsed as doubles in every JS layer, and a u64 loses precision above+ /// `Number.MAX_SAFE_INTEGER`, which silently corrupted ids and failed+ /// every bridge read/write with "unknown plugin file handle".+ handle_id: String,name: String,size: u64,content_type: String,@@ -102,21 +107,23 @@ fn guess_content_type(path: &Path) -> String {fn with_handles<T>(state: &PluginFileState,- body: impl FnOnce(&mut HashMap<u64, OpenFile>) -> Result<T, String>,+ body: impl FnOnce(&mut HashMap<String, OpenFile>) -> Result<T, String>,) -> Result<T, String> {let mut handles = state.handles.lock().map_err(|_| "plugin file registry poisoned".to_string())?;body(&mut handles)}fn owned_handle<'a>(- handles: &'a mut HashMap<u64, OpenFile>,+ handles: &'a mut HashMap<String, OpenFile>,plugin_id: &str,- handle_id: u64,+ handle_id: &str,) -> Result<&'a mut OpenFile, String> {- let entry = handles.get_mut(&handle_id).ok_or_else(|| "unknown plugin file handle".to_string())?;+ let entry = handles.get_mut(handle_id).ok_or_else(|| "unknown plugin file handle".to_string())?;if entry.owner != plugin_id {- // Deliberately indistinguishable from a missing handle: a plugin must- // not learn that another plugin's handle ids exist.+ // Response stays indistinguishable from a missing handle: a plugin must+ // not learn that another plugin's handle ids exist. The host log is the+ // one place the two cases can be told apart when debugging.+ log::warn!("plugin file handle belongs to another plugin (caller: {plugin_id})");return Err("unknown plugin file handle".to_string());}Ok(entry)@@ -162,10 +169,11 @@ pub fn open_plugin_file(return Err(format!("too many open plugin file handles (max {MAX_OPEN_HANDLES})"));}// Unguessable id: a plugin that can only reach its own bridge must not- // be able to walk the registry by trying sequential ids.- let bytes = Uuid::new_v4().into_bytes();- let handle_id = u64::from_be_bytes(bytes[0..8].try_into().expect("uuid prefix"));- handles.insert(handle_id, OpenFile { file, write, size, owner: plugin_id.to_string() });+ // be able to walk the registry by trying sequential ids. Same wire+ // convention as downloadId: uuid v4, carried as a string so no JS+ // layer can lose precision on it.+ let handle_id = Uuid::new_v4().to_string();+ handles.insert(handle_id.clone(), OpenFile { file, write, size, owner: plugin_id.to_string() });Ok(PluginFileHandle { handle_id, name, size, content_type: guess_content_type(path), write })})}@@ -173,7 +181,7 @@ pub fn open_plugin_file(pub fn read_plugin_file_chunk(state: &PluginFileState,plugin_id: &str,- handle_id: u64,+ handle_id: &str,offset: u64,length: Option<u32>,) -> Result<PluginFileReadChunk, String> {@@ -202,7 +210,7 @@ pub fn read_plugin_file_chunk(pub fn write_plugin_file_chunk(state: &PluginFileState,plugin_id: &str,- handle_id: u64,+ handle_id: &str,offset: u64,data_base64: &str,) -> Result<PluginFileWriteResult, String> {@@ -224,7 +232,7 @@ pub fn write_plugin_file_chunk(/// Close a handle. Write handles are flushed to disk before dropping; the/// bytes were already handed to the OS through `write_all`, so failure here/// means the OS could not flush — surfaced to the plugin as an error.-pub fn close_plugin_file(state: &PluginFileState, plugin_id: &str, handle_id: u64) -> Result<(), String> {+pub fn close_plugin_file(state: &PluginFileState, plugin_id: &str, handle_id: &str) -> Result<(), String> {with_handles(state, |handles| {{let entry = owned_handle(handles, plugin_id, handle_id)?;@@ -232,7 +240,7 @@ pub fn close_plugin_file(state: &PluginFileState, plugin_id: &str, handle_id: u6entry.file.sync_all().map_err(|error| format!("flush failed: {error}"))?;}}- handles.remove(&handle_id).map(|_| ()).ok_or_else(|| "unknown plugin file handle".to_string())+ handles.remove(handle_id).map(|_| ()).ok_or_else(|| "unknown plugin file handle".to_string())})}@@ -250,27 +258,31 @@ pub fn plugin_file_open(pub fn plugin_file_read(state: State<'_, PluginFileState>,plugin_id: String,- handle_id: u64,+ handle_id: String,offset: u64,length: Option<u32>,) -> Result<PluginFileReadChunk, String> {- read_plugin_file_chunk(&state, &plugin_id, handle_id, offset, length)+ read_plugin_file_chunk(&state, &plugin_id, &handle_id, offset, length)}#[tauri::command]pub fn plugin_file_write(state: State<'_, PluginFileState>,plugin_id: String,- handle_id: u64,+ handle_id: String,offset: u64,data_base64: String,) -> Result<PluginFileWriteResult, String> {- write_plugin_file_chunk(&state, &plugin_id, handle_id, offset, &data_base64)+ write_plugin_file_chunk(&state, &plugin_id, &handle_id, offset, &data_base64)}#[tauri::command]-pub fn plugin_file_close(state: State<'_, PluginFileState>, plugin_id: String, handle_id: u64) -> Result<(), String> {- close_plugin_file(&state, &plugin_id, handle_id)+pub fn plugin_file_close(+ state: State<'_, PluginFileState>,+ plugin_id: String,+ handle_id: String,+) -> Result<(), String> {+ close_plugin_file(&state, &plugin_id, &handle_id)}#[cfg(test)]@@ -296,15 +308,15 @@ mod tests {assert!(!handle.write);assert_eq!(handle.content_type, "application/octet-stream");- let chunk = read_plugin_file_chunk(&state, OWNER, handle.handle_id, 6, Some(6)).expect("read");+ let chunk = read_plugin_file_chunk(&state, OWNER, &handle.handle_id, 6, Some(6)).expect("read");assert_eq!(BASE64.decode(chunk.data_base64).unwrap(), b"plugin");assert!(!chunk.eof);- let tail = read_plugin_file_chunk(&state, OWNER, handle.handle_id, 13, Some(64)).expect("read tail");+ let tail = read_plugin_file_chunk(&state, OWNER, &handle.handle_id, 13, Some(64)).expect("read tail");assert_eq!(BASE64.decode(tail.data_base64).unwrap(), b"bridge");assert!(tail.eof);- close_plugin_file(&state, OWNER, handle.handle_id).expect("close");- assert!(read_plugin_file_chunk(&state, OWNER, handle.handle_id, 0, None).is_err());+ close_plugin_file(&state, OWNER, &handle.handle_id).expect("close");+ assert!(read_plugin_file_chunk(&state, OWNER, &handle.handle_id, 0, None).is_err());let _ = std::fs::remove_file(path);}@@ -314,16 +326,16 @@ mod tests {let state = PluginFileState::new();let handle = open_plugin_file(&state, OWNER, path.to_string_lossy().as_ref(), false).expect("open");- let foreign_read = read_plugin_file_chunk(&state, OTHER, handle.handle_id, 0, None).unwrap_err();+ let foreign_read = read_plugin_file_chunk(&state, OTHER, &handle.handle_id, 0, None).unwrap_err();assert_eq!(foreign_read, "unknown plugin file handle");let foreign_write =- write_plugin_file_chunk(&state, OTHER, handle.handle_id, 0, &BASE64.encode(b"x")).unwrap_err();+ write_plugin_file_chunk(&state, OTHER, &handle.handle_id, 0, &BASE64.encode(b"x")).unwrap_err();assert_eq!(foreign_write, "unknown plugin file handle");- let foreign_close = close_plugin_file(&state, OTHER, handle.handle_id).unwrap_err();+ let foreign_close = close_plugin_file(&state, OTHER, &handle.handle_id).unwrap_err();assert_eq!(foreign_close, "unknown plugin file handle");- assert!(read_plugin_file_chunk(&state, OWNER, handle.handle_id, 0, None).is_ok());+ assert!(read_plugin_file_chunk(&state, OWNER, &handle.handle_id, 0, None).is_ok());- close_plugin_file(&state, OWNER, handle.handle_id).expect("close");+ close_plugin_file(&state, OWNER, &handle.handle_id).expect("close");let _ = std::fs::remove_file(path);}@@ -335,15 +347,15 @@ mod tests {assert!(handle.write);assert_eq!(handle.size, 0);assert!(- read_plugin_file_chunk(&state, OWNER, handle.handle_id, 0, None).is_err(),+ read_plugin_file_chunk(&state, OWNER, &handle.handle_id, 0, None).is_err(),"write handles reject reads");let written =- write_plugin_file_chunk(&state, OWNER, handle.handle_id, 0, &BASE64.encode(b"fresh")).expect("write");+ write_plugin_file_chunk(&state, OWNER, &handle.handle_id, 0, &BASE64.encode(b"fresh")).expect("write");assert_eq!(written.written, 5);assert_eq!(written.next_offset, 5);- close_plugin_file(&state, OWNER, handle.handle_id).expect("close");+ close_plugin_file(&state, OWNER, &handle.handle_id).expect("close");assert_eq!(std::fs::read(&path).unwrap(), b"fresh");let _ = std::fs::remove_file(path);@@ -355,8 +367,8 @@ mod tests {let _ = std::fs::remove_file(&path);let state = PluginFileState::new();let handle = open_plugin_file(&state, OWNER, path.to_string_lossy().as_ref(), true).expect("open write");- write_plugin_file_chunk(&state, OWNER, handle.handle_id, 0, &BASE64.encode(b"data")).expect("write");- close_plugin_file(&state, OWNER, handle.handle_id).expect("close");+ write_plugin_file_chunk(&state, OWNER, &handle.handle_id, 0, &BASE64.encode(b"data")).expect("write");+ close_plugin_file(&state, OWNER, &handle.handle_id).expect("close");assert_eq!(std::fs::read(&path).unwrap(), b"data");let _ = std::fs::remove_file(path);}@@ -368,8 +380,8 @@ mod tests {open_plugin_file(&state, OWNER, std::env::temp_dir().to_string_lossy().as_ref(), false).unwrap_err();assert!(error.contains("directory"));assert!(open_plugin_file(&state, " ", std::env::temp_dir().to_string_lossy().as_ref(), false).is_err());- assert!(read_plugin_file_chunk(&state, OWNER, 999_999, 0, None).is_err());- assert!(close_plugin_file(&state, OWNER, 999_999).is_err());+ assert!(read_plugin_file_chunk(&state, OWNER, "00000000-0000-4000-8000-000000000099", 0, None).is_err());+ assert!(close_plugin_file(&state, OWNER, "00000000-0000-4000-8000-000000000099").is_err());}#[test]@@ -377,11 +389,11 @@ mod tests {let path = temp_file("bounds.bin", b"abc");let state = PluginFileState::new();let handle = open_plugin_file(&state, OWNER, path.to_string_lossy().as_ref(), false).expect("open");- assert!(read_plugin_file_chunk(&state, OWNER, handle.handle_id, 4, None).is_err());- let at_end = read_plugin_file_chunk(&state, OWNER, handle.handle_id, 3, None).expect("read at eof");+ assert!(read_plugin_file_chunk(&state, OWNER, &handle.handle_id, 4, None).is_err());+ let at_end = read_plugin_file_chunk(&state, OWNER, &handle.handle_id, 3, None).expect("read at eof");assert!(at_end.eof);assert_eq!(at_end.length, 0);- close_plugin_file(&state, OWNER, handle.handle_id).expect("close");+ close_plugin_file(&state, OWNER, &handle.handle_id).expect("close");let _ = std::fs::remove_file(path);}@@ -391,14 +403,36 @@ mod tests {let state = PluginFileState::new();let handle = open_plugin_file(&state, OWNER, path.to_string_lossy().as_ref(), false).expect("open");assert_eq!(handle.content_type, "image/svg+xml");- close_plugin_file(&state, OWNER, handle.handle_id).expect("close");+ close_plugin_file(&state, OWNER, &handle.handle_id).expect("close");let _ = std::fs::remove_file(&path);path.set_extension("weird");std::fs::write(&path, b"x").unwrap();let handle = open_plugin_file(&state, OWNER, path.to_string_lossy().as_ref(), false).expect("open");assert_eq!(handle.content_type, "application/octet-stream");- close_plugin_file(&state, OWNER, handle.handle_id).expect("close");+ close_plugin_file(&state, OWNER, &handle.handle_id).expect("close");+ let _ = std::fs::remove_file(path);+ }++ #[test]+ fn handle_id_follows_the_uuid_string_wire_convention() {+ // Handle ids ride the bridge as opaque strings, same as downloadId.+ // The old wire format serialized a u64 JSON number: ids above+ // Number.MAX_SAFE_INTEGER were rounded by every JS layer, so the host+ // looked a fresh handle up under a different key and failed every+ // read/write with "unknown plugin file handle".+ let path = temp_file("wire-uuid.bin", b"payload");+ let state = PluginFileState::new();+ let handle = open_plugin_file(&state, OWNER, path.to_string_lossy().as_ref(), false).expect("open");+ let wire_json = serde_json::to_string(&handle.handle_id).expect("serialize id");+ assert_eq!(wire_json, format!("\"{}\"", handle.handle_id), "the wire id is a JSON string, never a number");+ let parsed = uuid::Uuid::parse_str(&handle.handle_id).expect("id parses as uuid, like downloadId");+ assert_eq!(parsed.to_string(), handle.handle_id);++ // The exact string the host sent back must hit the same registry key.+ let chunk = read_plugin_file_chunk(&state, OWNER, &handle.handle_id, 0, None).expect("read via wire id");+ assert_eq!(BASE64.decode(chunk.data_base64).unwrap(), b"payload");+ close_plugin_file(&state, OWNER, &handle.handle_id).expect("close");let _ = std::fs::remove_file(path);}}