auvrynt 1.0.2 → 1.0.5

package/dist/integrations/images/view-image.js

@@ -0,0 +1,99 @@
+import { extname } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { inlineImageOrNotice } from "../../tool-result-budget.js";
+const MAX_IMAGE_SIZE_BYTES = 20 * 1024 * 1024;
+const SUPPORTED_MIME_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+};
+export async function executeViewImage(registry, input) {
+    let workspace;
+    try {
+        workspace = registry.getWorkspace(input.workspaceId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: message }],
+            isError: true,
+        };
+    }
+    const ext = extname(input.path).toLowerCase();
+    const mimeType = SUPPORTED_MIME_TYPES[ext];
+    if (!mimeType) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unsupported image extension "${ext}". Supported extensions: .png, .jpg, .jpeg, .webp, .gif`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    let absolutePath;
+    try {
+        absolutePath = registry.resolvePath(workspace, input.path);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: message }],
+            isError: true,
+        };
+    }
+    let stats;
+    try {
+        stats = await stat(absolutePath);
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: `File not found: ${input.path}` }],
+            isError: true,
+        };
+    }
+    if (stats.isDirectory()) {
+        return {
+            content: [
+                { type: "text", text: `Path is a directory, not a file: ${input.path}` },
+            ],
+            isError: true,
+        };
+    }
+    if (!stats.isFile()) {
+        return {
+            content: [
+                { type: "text", text: `Path is not a regular file: ${input.path}` },
+            ],
+            isError: true,
+        };
+    }
+    if (stats.size > MAX_IMAGE_SIZE_BYTES) {
+        const sizeMb = (stats.size / (1024 * 1024)).toFixed(2);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Image file size (${sizeMb} MB) exceeds maximum allowed limit of 20 MB.`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    try {
+        const buffer = await readFile(absolutePath);
+        return {
+            content: inlineImageOrNotice(buffer, `Image ${input.path}`, mimeType),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Failed to read image file: ${message}` }],
+            isError: true,
+        };
+    }
+}

package/dist/integrations/images/window-capture.js

@@ -0,0 +1,148 @@
+import { readFile, mkdir } from "node:fs/promises";
+import { dirname, relative } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { inlineImageOrNotice } from "../../tool-result-budget.js";
+const execFileAsync = promisify(execFile);
+const MAX_WINDOW_TITLE_CHARS = 256;
+export async function captureWindow(registry, processManager, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absoluteOutputPath = registry.resolveArtifactPath(workspace, input.outputPath, "captures");
+    if (process.platform !== "win32") {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Window capture is currently supported on Windows hosts. Operating system "${process.platform}" is not supported.`,
+                }],
+            isError: true,
+        };
+    }
+    const title = input.windowTitle?.trim();
+    if (!input.processId && !title) {
+        return {
+            content: [{ type: "text", text: "Window capture requires processId or windowTitle. Full-screen capture is intentionally disabled." }],
+            isError: true,
+        };
+    }
+    if (title && title.length > MAX_WINDOW_TITLE_CHARS) {
+        return {
+            content: [{ type: "text", text: `windowTitle exceeds ${MAX_WINDOW_TITLE_CHARS} characters.` }],
+            isError: true,
+        };
+    }
+    let pid;
+    if (input.processId) {
+        const tracked = processManager.getTrackedProcess(input.workspaceId, input.processId);
+        if (tracked.status !== "running") {
+            return {
+                content: [{ type: "text", text: `Tracked process ${input.processId} is not running.` }],
+                isError: true,
+            };
+        }
+        pid = tracked.pid;
+        if (!pid) {
+            return {
+                content: [{ type: "text", text: `Tracked process ${input.processId} does not have a process ID.` }],
+                isError: true,
+            };
+        }
+    }
+    const psScript = String.raw `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Drawing
+Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+public static class AuvryntNativeWindow {
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RECT { public int Left; public int Top; public int Right; public int Bottom; }
+    [DllImport("user32.dll")]
+    public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+    [DllImport("user32.dll")]
+    public static extern bool PrintWindow(IntPtr hWnd, IntPtr hdcBlt, uint flags);
+}
+"@
+
+function Find-WindowForProcess([int]$RootPid) {
+    $queue = [System.Collections.Generic.Queue[int]]::new()
+    $seen = [System.Collections.Generic.HashSet[int]]::new()
+    $queue.Enqueue($RootPid)
+    while ($queue.Count -gt 0) {
+        $currentPid = $queue.Dequeue()
+        if (-not $seen.Add($currentPid)) { continue }
+        $proc = Get-Process -Id $currentPid -ErrorAction SilentlyContinue
+        if ($proc -and $proc.MainWindowHandle -ne [IntPtr]::Zero) { return $proc.MainWindowHandle }
+        Get-CimInstance Win32_Process -Filter "ParentProcessId=$currentPid" -ErrorAction SilentlyContinue | ForEach-Object {
+            $queue.Enqueue([int]$_.ProcessId)
+        }
+    }
+    return [IntPtr]::Zero
+}
+
+$handle = [IntPtr]::Zero
+if ($env:AUVRYNT_CAPTURE_PID) {
+    $handle = Find-WindowForProcess ([int]$env:AUVRYNT_CAPTURE_PID)
+}
+if ($handle -eq [IntPtr]::Zero -and $env:AUVRYNT_CAPTURE_TITLE) {
+    $needle = $env:AUVRYNT_CAPTURE_TITLE
+    $proc = Get-Process | Where-Object {
+        $_.MainWindowHandle -ne [IntPtr]::Zero -and
+        $_.MainWindowTitle.IndexOf($needle, [StringComparison]::OrdinalIgnoreCase) -ge 0
+    } | Select-Object -First 1
+    if ($proc) { $handle = $proc.MainWindowHandle }
+}
+if ($handle -eq [IntPtr]::Zero) { throw 'Target application window was not found.' }
+
+$rect = New-Object AuvryntNativeWindow+RECT
+if (-not [AuvryntNativeWindow]::GetWindowRect($handle, [ref]$rect)) { throw 'Could not read target window bounds.' }
+$width = $rect.Right - $rect.Left
+$height = $rect.Bottom - $rect.Top
+if ($width -lt 1 -or $height -lt 1 -or $width -gt 16384 -or $height -gt 16384) {
+    throw "Invalid target window bounds: $($width)x$($height)"
+}
+
+$bmp = New-Object System.Drawing.Bitmap $width, $height
+$graphics = [System.Drawing.Graphics]::FromImage($bmp)
+try {
+    $hdc = $graphics.GetHdc()
+    try { $printed = [AuvryntNativeWindow]::PrintWindow($handle, $hdc, 2) }
+    finally { $graphics.ReleaseHdc($hdc) }
+    if (-not $printed) {
+        $graphics.CopyFromScreen($rect.Left, $rect.Top, 0, 0, $bmp.Size)
+    }
+    $bmp.Save($env:AUVRYNT_CAPTURE_OUTPUT, [System.Drawing.Imaging.ImageFormat]::Png)
+} finally {
+    $graphics.Dispose()
+    $bmp.Dispose()
+}
+`;
+    await mkdir(dirname(absoluteOutputPath), { recursive: true });
+    try {
+        await execFileAsync("powershell", ["-NoProfile", "-NonInteractive", "-Command", psScript], {
+            env: {
+                ...process.env,
+                AUVRYNT_CAPTURE_PID: pid ? String(pid) : "",
+                AUVRYNT_CAPTURE_TITLE: title ?? "",
+                AUVRYNT_CAPTURE_OUTPUT: absoluteOutputPath,
+            },
+            maxBuffer: 1024 * 1024,
+            timeout: 20_000,
+            windowsHide: true,
+        });
+        const buffer = await readFile(absoluteOutputPath);
+        const relPath = relative(workspace.root, absoluteOutputPath).replace(/\\/g, "/");
+        return {
+            content: [
+                ...inlineImageOrNotice(buffer, `Window capture ${relPath}`, "image/png"),
+                { type: "text", text: `Captured target window screenshot to ${relPath}` },
+            ],
+        };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Window capture failed: ${msg}` }],
+            isError: true,
+        };
+    }
+}

package/dist/integrations/integration-discovery.js

@@ -0,0 +1,185 @@
+import { existsSync } from "node:fs";
+import { createConnection } from "node:net";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { loadConfig } from "../config.js";
+const execFileAsync = promisify(execFile);
+const PROCESS_MARKERS = {
+    blender: ["blender.exe", "blender"],
+    aseprite: ["aseprite.exe", "aseprite"],
+    godot: ["godot.exe", "godot4.exe", "godot"],
+    cloudflare_tunnel: ["cloudflared.exe", "cloudflared"],
+    serena: ["serena.exe", "serena"],
+    roblox: ["robloxstudiobeta.exe", "robloxstudio.exe", "robloxplayerbeta.exe"],
+};
+export const DEFAULT_INTEGRATION_DISCOVERY_CACHE_MS = 10_000;
+let cachedDiscovery;
+let discoveryInFlight;
+function probePort(host, port, timeoutMs = 350) {
+    return new Promise((resolve) => {
+        const socket = createConnection({ host, port });
+        let finished = false;
+        const finish = (available) => {
+            if (finished)
+                return;
+            finished = true;
+            socket.destroy();
+            resolve(available);
+        };
+        const timeout = setTimeout(() => finish(false), timeoutMs);
+        socket.once("connect", () => {
+            clearTimeout(timeout);
+            finish(true);
+        });
+        socket.once("error", () => {
+            clearTimeout(timeout);
+            finish(false);
+        });
+    });
+}
+async function runningProcessNames() {
+    if (process.platform !== "win32")
+        return [];
+    try {
+        const { stdout } = await execFileAsync("tasklist.exe", ["/FO", "CSV", "/NH"], {
+            timeout: 5_000,
+            windowsHide: true,
+        });
+        return stdout
+            .split(/\r?\n/)
+            .map((line) => line.match(/^"([^"]+)"/)?.[1]?.toLowerCase())
+            .filter((name) => Boolean(name));
+    }
+    catch {
+        return [];
+    }
+}
+async function findExecutable(command) {
+    const exes = process.platform === "win32" ? [`${command}.exe`, command] : [command];
+    const userBinDirs = [
+        join(homedir(), ".auvrynt", "bin"),
+        join(homedir(), ".local", "bin"),
+        join(homedir(), "AppData", "Roaming", "Python", "Scripts"),
+    ];
+    for (const dir of userBinDirs) {
+        for (const exe of exes) {
+            const fullPath = join(dir, exe);
+            if (existsSync(fullPath))
+                return fullPath;
+        }
+    }
+    try {
+        const cmd = process.platform === "win32" ? "where.exe" : "which";
+        const { stdout } = await execFileAsync(cmd, [command], {
+            timeout: 5_000,
+            windowsHide: true,
+        });
+        return stdout.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+    }
+    catch {
+        return undefined;
+    }
+}
+function findAsepriteInSource(sourcePath) {
+    if (!sourcePath)
+        return undefined;
+    const candidates = process.platform === "win32"
+        ? [join(sourcePath, "build", "bin", "aseprite.exe"), join(sourcePath, "bin", "aseprite.exe"), join(sourcePath, "aseprite.exe")]
+        : [join(sourcePath, "build", "bin", "aseprite"), join(sourcePath, "bin", "aseprite"), join(sourcePath, "aseprite")];
+    return candidates.find((candidate) => existsSync(candidate));
+}
+function hasProcess(processes, markers) {
+    return processes.some((processName) => markers.some((marker) => processName === marker || processName.includes(marker)));
+}
+export async function discoverLocalIntegrations(options = {}) {
+    const cacheMs = Math.max(0, options.cacheMs ?? DEFAULT_INTEGRATION_DISCOVERY_CACHE_MS);
+    const forceRefresh = options.forceRefresh === true || (options.pollMs ?? 0) > 0;
+    const now = Date.now();
+    if (!forceRefresh
+        && cacheMs > 0
+        && cachedDiscovery
+        && now - cachedDiscovery.cachedAt < cacheMs) {
+        return cloneDiscovery(cachedDiscovery.value);
+    }
+    const inFlight = discoveryInFlight ??= performDiscovery(options.pollMs ?? 0);
+    try {
+        const result = await inFlight;
+        cachedDiscovery = { value: result, cachedAt: Date.now() };
+        return cloneDiscovery(result);
+    }
+    finally {
+        if (discoveryInFlight === inFlight)
+            discoveryInFlight = undefined;
+    }
+}
+async function performDiscovery(pollMs) {
+    let configExecs = {};
+    try {
+        const config = loadConfig();
+        configExecs = config.executables;
+    }
+    catch { }
+    const blenderMcpPort = Number(process.env.AUVRYNT_BLENDER_MCP_PORT ?? 9876);
+    const boundedPollMs = Math.max(0, pollMs);
+    const pollPort = async (port) => {
+        const deadline = Date.now() + boundedPollMs;
+        do {
+            if (await probePort("127.0.0.1", port))
+                return true;
+            if (Date.now() >= deadline)
+                return false;
+            await new Promise((resolveDelay) => setTimeout(resolveDelay, 250));
+        } while (Date.now() <= deadline);
+        return false;
+    };
+    const configuredAseprite = configExecs.aseprite || findAsepriteInSource(configExecs.asepriteSource);
+    const [processes, cloudflaredSys, serenaSys, godotSys, blenderSys, asepriteSys, blenderLabMcp, auvryntBlenderBridge, auvryntGodotBridge] = await Promise.all([
+        runningProcessNames(),
+        configExecs.cloudflared ? undefined : findExecutable("cloudflared"),
+        configExecs.serena ? undefined : findExecutable("serena"),
+        configExecs.godot || configExecs.godotCsharp ? undefined : findExecutable("godot"),
+        configExecs.blender ? undefined : findExecutable("blender"),
+        configuredAseprite ? undefined : findExecutable("aseprite"),
+        pollPort(blenderMcpPort),
+        pollPort(49323),
+        pollPort(49322),
+    ]);
+    const cloudflared = configExecs.cloudflared || cloudflaredSys;
+    const serena = configExecs.serena || serenaSys;
+    const godot = configExecs.godot || godotSys;
+    const godotCsharp = configExecs.godotCsharp;
+    const blender = configExecs.blender || blenderSys;
+    const aseprite = configuredAseprite || asepriteSys;
+    return {
+        processes,
+        executables: {
+            cloudflared,
+            serena,
+            godot,
+            godotCsharp,
+            blender,
+            aseprite,
+            asepriteSource: configExecs.asepriteSource,
+        },
+        ports: {
+            blender_lab_mcp: blenderLabMcp,
+            auvrynt_blender_bridge: auvryntBlenderBridge,
+            auvrynt_godot_bridge: auvryntGodotBridge,
+        },
+    };
+}
+function cloneDiscovery(discovery) {
+    return {
+        processes: [...discovery.processes],
+        executables: { ...discovery.executables },
+        ports: { ...discovery.ports },
+    };
+}
+export function clearIntegrationDiscoveryCache() {
+    cachedDiscovery = undefined;
+}
+export function processDetected(discovery, integration) {
+    return hasProcess(discovery.processes, PROCESS_MARKERS[integration]);
+}

package/dist/integrations/obsidian/obsidian-tools.js

@@ -0,0 +1,205 @@
+import { createReadStream, existsSync } from "node:fs";
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, extname, join, relative, resolve, sep } from "node:path";
+import * as z from "zod/v4";
+import { registerAppTool } from "../../server/mcp-tool-registrar.js";
+import { expandHomePath } from "../../roots.js";
+import { createInterface } from "node:readline";
+const READ_ONLY = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+const MUTATING = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+function text(payload, isError = false) {
+    return {
+        content: [{ type: "text", text: typeof payload === "string" ? payload : JSON.stringify(payload, null, 2) }],
+        ...(isError ? { isError: true } : {}),
+    };
+}
+function resolveVaultRoot(config) {
+    const raw = config.obsidian.vaultPath?.trim();
+    if (!raw) {
+        throw new Error("Obsidian vault path is not configured. Set AUVRYNT_OBSIDIAN_VAULT or config.obsidian.vaultPath to your vault folder.");
+    }
+    return resolve(expandHomePath(raw));
+}
+function assertInsideVault(vaultRoot, target) {
+    const absolute = resolve(vaultRoot, target);
+    const root = vaultRoot.endsWith(sep) ? vaultRoot : vaultRoot + sep;
+    if (absolute !== vaultRoot && !absolute.startsWith(root)) {
+        throw new Error("Path escapes the configured Obsidian vault.");
+    }
+    return absolute;
+}
+async function listMarkdownFiles(vaultRoot, subdir = "", limit = 200) {
+    const results = [];
+    async function walk(dir) {
+        if (results.length >= limit)
+            return;
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (results.length >= limit)
+                return;
+            if (entry.name.startsWith("."))
+                continue;
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === "node_modules" || entry.name === ".obsidian")
+                    continue;
+                await walk(full);
+            }
+            else if (entry.isFile() && ["md", "markdown"].includes(extname(entry.name).slice(1).toLowerCase())) {
+                results.push(relative(vaultRoot, full).replace(/\\/g, "/"));
+            }
+        }
+    }
+    const start = subdir ? assertInsideVault(vaultRoot, subdir) : vaultRoot;
+    if (!existsSync(start))
+        throw new Error(`Vault path not found: ${start}`);
+    await walk(start);
+    return results;
+}
+export function registerObsidianTools(server, config) {
+    registerAppTool(server, "obsidian_status", {
+        title: "Obsidian vault status",
+        description: "Report the configured Obsidian vault path and whether it exists on disk.",
+        inputSchema: {},
+        annotations: READ_ONLY,
+        _meta: {},
+    }, async () => {
+        try {
+            const vaultPath = config.obsidian.vaultPath
+                ? resolve(expandHomePath(config.obsidian.vaultPath))
+                : null;
+            const exists = vaultPath ? existsSync(vaultPath) : false;
+            let noteCount = null;
+            if (exists && vaultPath) {
+                noteCount = (await listMarkdownFiles(vaultPath, "", 5_000)).length;
+            }
+            return text({
+                configured: Boolean(vaultPath),
+                vaultPath,
+                exists,
+                noteCount,
+            });
+        }
+        catch (error) {
+            return text(error instanceof Error ? error.message : String(error), true);
+        }
+    });
+    registerAppTool(server, "obsidian_list_notes", {
+        title: "List Obsidian notes",
+        description: "List markdown notes under the configured Obsidian vault (relative paths).",
+        inputSchema: {
+            subdir: z.string().optional().describe("Optional subdirectory relative to the vault root."),
+            limit: z.number().int().min(1).max(2000).optional().describe("Max notes to return (default 200)."),
+        },
+        annotations: READ_ONLY,
+        _meta: {},
+    }, async ({ subdir, limit }) => {
+        try {
+            const vault = resolveVaultRoot(config);
+            const notes = await listMarkdownFiles(vault, subdir ?? "", limit ?? 200);
+            return text({ vault, count: notes.length, notes });
+        }
+        catch (error) {
+            return text(error instanceof Error ? error.message : String(error), true);
+        }
+    });
+    registerAppTool(server, "obsidian_read_note", {
+        title: "Read Obsidian note",
+        description: "Read a markdown note from the configured Obsidian vault by relative path.",
+        inputSchema: {
+            path: z.string().min(1).describe("Note path relative to the vault root (e.g. Projects/idea.md)."),
+        },
+        annotations: READ_ONLY,
+        _meta: {},
+    }, async ({ path }) => {
+        try {
+            const vault = resolveVaultRoot(config);
+            const absolute = assertInsideVault(vault, path);
+            const content = await readFile(absolute, "utf8");
+            const info = await stat(absolute);
+            return text({
+                path: relative(vault, absolute).replace(/\\/g, "/"),
+                bytes: info.size,
+                modifiedAt: info.mtime.toISOString(),
+                content,
+            });
+        }
+        catch (error) {
+            return text(error instanceof Error ? error.message : String(error), true);
+        }
+    });
+    registerAppTool(server, "obsidian_search", {
+        title: "Search Obsidian vault",
+        description: "Case-insensitive full-text search across markdown notes in the configured vault.",
+        inputSchema: {
+            query: z.string().min(1).describe("Text to search for."),
+            limit: z.number().int().min(1).max(100).optional().describe("Max matching notes (default 25)."),
+        },
+        annotations: READ_ONLY,
+        _meta: {},
+    }, async ({ query, limit }) => {
+        try {
+            const vault = resolveVaultRoot(config);
+            const notes = await listMarkdownFiles(vault, "", 5_000);
+            const needle = query.toLowerCase();
+            const max = limit ?? 25;
+            const matches = [];
+            for (const note of notes) {
+                if (matches.length >= max)
+                    break;
+                const absolute = join(vault, note);
+                const stream = createReadStream(absolute, { encoding: "utf8" });
+                const rl = createInterface({ input: stream, crlfDelay: Infinity });
+                let lineNo = 0;
+                for await (const line of rl) {
+                    lineNo += 1;
+                    if (line.toLowerCase().includes(needle)) {
+                        matches.push({ path: note, line: lineNo, preview: line.trim().slice(0, 240) });
+                        if (matches.length >= max)
+                            break;
+                    }
+                }
+            }
+            return text({ vault, query, count: matches.length, matches });
+        }
+        catch (error) {
+            return text(error instanceof Error ? error.message : String(error), true);
+        }
+    });
+    registerAppTool(server, "obsidian_write_note", {
+        title: "Write Obsidian note",
+        description: "Create or overwrite a markdown note in the configured Obsidian vault.",
+        inputSchema: {
+            path: z.string().min(1).describe("Note path relative to the vault root. .md is appended if missing."),
+            content: z.string().describe("Full markdown body to write."),
+            append: z.boolean().optional().describe("If true, append to an existing note instead of replacing."),
+        },
+        annotations: MUTATING,
+        _meta: {},
+    }, async ({ path, content, append }) => {
+        try {
+            const vault = resolveVaultRoot(config);
+            let rel = path.replace(/\\/g, "/");
+            if (!rel.toLowerCase().endsWith(".md") && !rel.toLowerCase().endsWith(".markdown")) {
+                rel = `${rel}.md`;
+            }
+            const absolute = assertInsideVault(vault, rel);
+            await mkdir(dirname(absolute), { recursive: true });
+            if (append && existsSync(absolute)) {
+                const previous = await readFile(absolute, "utf8");
+                await writeFile(absolute, `${previous}${previous.endsWith("\n") ? "" : "\n"}${content}`, "utf8");
+            }
+            else {
+                await writeFile(absolute, content, "utf8");
+            }
+            return text({
+                path: relative(vault, absolute).replace(/\\/g, "/"),
+                bytes: Buffer.byteLength(content, "utf8"),
+                append: Boolean(append),
+            });
+        }
+        catch (error) {
+            return text(error instanceof Error ? error.message : String(error), true);
+        }
+    });
+}