context-mode 0.4.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,29 @@
+{
+  "name": "context-mode",
+  "version": "0.4.0",
+  "description": "Claude Code MCP plugin that saves 94% of your context window. Sandboxed code execution in 10 languages, FTS5 knowledge base with BM25 ranking, and smart truncation.",
+  "author": {
+    "name": "Mert Koseoğlu",
+    "url": "https://github.com/mksglu"
+  },
+  "homepage": "https://github.com/mksglu/claude-context-mode#readme",
+  "repository": "https://github.com/mksglu/claude-context-mode",
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "context-window",
+    "sandbox",
+    "code-execution",
+    "fts5",
+    "bm25",
+    "playwright",
+    "context7"
+  ],
+  "mcpServers": {
+    "context-mode": {
+      "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/build/server.js"]
+    }
+  },
+  "skills": "./skills/"
+}

package/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "context-mode": {
+      "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/build/server.js"]
+    }
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mert Koseoğlu
+
+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.

package/README.md

@@ -0,0 +1,304 @@
+# Context Mode
+
+**Claude Code MCP plugin that saves 94% of your context window.**
+
+Every tool call in Claude Code consumes context tokens. A single Playwright snapshot burns 10K-135K tokens. A Context7 docs lookup dumps 4K-10K tokens. GitHub's `list_commits` with 30 results costs 29K-64K tokens. With 5+ MCP servers active, you lose ~55K tokens before your first message — and after 30 minutes of real debugging, responses slow to a crawl.
+
+Context Mode intercepts these operations, processes data in isolated subprocesses, and returns only what matters.
+
+## The Problem: MCP Context Bloat
+
+Claude Code has a 200K token context window. Here's how fast popular MCP servers eat through it:
+
+| MCP Server | Tool | Output per Call | Source |
+|---|---|---|---|
+| **Playwright** | `browser_snapshot` | 10K-135K tokens (50-540 KB) | [playwright-mcp#1233](https://github.com/microsoft/playwright-mcp/issues/1233) |
+| **Context7** | `query-docs` | 4K-10K tokens per query | [upstash/context7](https://github.com/upstash/context7) |
+| **GitHub** | `list_commits` (30) | 29K-64K tokens | [github-mcp-server#142](https://github.com/github/github-mcp-server/issues/142) |
+| **Sentry** | full mode tools | 14K tokens (definitions only) | [getsentry/sentry-mcp](https://github.com/getsentry/sentry-mcp) |
+| **Supabase** | database tools | 4.2K tokens (definitions only) | [supabase-community/supabase-mcp](https://github.com/supabase-community/supabase-mcp) |
+| **Firecrawl** | `scrape` / `crawl` | 5K-50K+ tokens per page | [firecrawl](https://github.com/mendableai/firecrawl) |
+| **Chrome DevTools** | all tools | 17K tokens (definitions only) | Community benchmark |
+| **Fetch** | `fetch` | 5K-50K tokens per page | Official reference server |
+
+**Real measurement** ([Scott Spence, 2025](https://scottspence.com/posts/optimising-mcp-server-context-usage-in-claude-code)): With 81+ MCP tools enabled across multiple servers, **143K of 200K tokens (72%) consumed** — 82K tokens just for MCP tool definitions. Only 28% left for actual work.
+
+**Vercel's finding** ([December 2025](https://www.anthropic.com/engineering/advanced-tool-use)): Removing 80% of tools resulted in 3.5x faster execution, 37% fewer tokens, and 100% success rate (up from 80%).
+
+## Before / After
+
+| What you're doing | Without Context Mode | With Context Mode | Savings |
+|---|---|---|---|
+| Playwright `browser_snapshot` | 12 KB into context | 50 B summary | **99%** |
+| Context7 `query-docs` (React) | 60 KB raw docs | 285 B search result | **99%** |
+| `gh pr list` / `gh api` | 8 KB JSON response | 40 B summary | **99%** |
+| Read `access.log` (500 req) | 45 KB raw log | 71 B status breakdown | **99%** |
+| `npm test` (30 suites) | 6 KB raw output | 37 B pass/fail | **99%** |
+| Git log (153 commits) | 12 KB raw log | 18 B summary | **99%** |
+| Supabase Edge Functions docs | 4 KB raw docs | 123 B code example | **97%** |
+
+**Real aggregate across 13 scenarios: 194 KB raw → 12.6 KB context (94% savings)**
+
+## Quick Start
+
+### Option 1: Claude Code Plugin (Recommended)
+
+```bash
+/plugin install context-mode@claude-plugin-directory
+```
+
+Installs as a Claude Code plugin with skills and MCP server bundled together.
+
+### Option 2: MCP Server Only
+
+```bash
+claude mcp add context-mode -- npx -y context-mode
+```
+
+Restart Claude Code. 5 tools are now available.
+
+## Tools
+
+### `execute` — Run Code in Sandbox
+
+Execute code in 10 languages: JavaScript, TypeScript, Python, Shell, Ruby, Go, Rust, PHP, Perl, R. Only stdout enters context — raw data stays in the subprocess.
+
+```
+Claude calls: execute({ language: "shell", code: "gh pr list --json title,state | jq length" })
+Returns: "3"                  ← 2 bytes instead of 8KB JSON
+```
+
+Authenticated CLIs work out of the box — `gh`, `aws`, `gcloud`, `kubectl`, `docker` credentials are passed through securely. Bun auto-detected for 3-5x faster JS/TS.
+
+### `execute_file` — Process Files Without Loading
+
+File contents never enter context. The file is read into a `FILE_CONTENT` variable inside the sandbox.
+
+```
+Claude calls: execute_file({ path: "access.log", language: "python", code: "..." })
+Returns: "200: 312 | 404: 89 | 500: 14"     ← 30 bytes instead of 45KB
+```
+
+### `index` — Build Searchable Knowledge Base
+
+Chunks markdown by headings, keeps code blocks intact, stores in ephemeral FTS5 database with BM25 ranking.
+
+```
+Claude calls: index({ content: <60KB React docs>, source: "React useEffect" })
+Returns: "Indexed 33 sections (15 with code)"     ← 40 bytes
+```
+
+### `search` — Retrieve Exact Content
+
+BM25 full-text search with Porter stemming. Returns exact code blocks — not summaries.
+
+```
+Claude calls: search({ query: "useEffect cleanup function" })
+Returns: exact code example with heading context     ← 500 bytes instead of 60KB
+```
+
+### `fetch_and_index` — Fetch & Index URLs
+
+Fetches URL in subprocess, converts HTML to markdown, indexes into FTS5. Raw content never enters context.
+
+```
+Claude calls: fetch_and_index({ url: "https://react.dev/reference/react/useEffect" })
+Returns: "Indexed 33 sections (15 with code)"     ← 40 bytes instead of 60KB
+```
+
+Use instead of WebFetch or Context7 when you need documentation — index once, search many times.
+
+## How It Works
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│ Without Context Mode                                             │
+│                                                                  │
+│ Claude Code → Playwright snapshot → 12KB into context            │
+│ Claude Code → Context7 docs      → 60KB into context             │
+│ Claude Code → gh pr list         →  8KB into context             │
+│ Claude Code → cat access.log     → 45KB into context             │
+│                                                                  │
+│ Total: 125KB consumed = ~32,000 tokens = 16% of context gone     │
+└──────────────────────────────────────────────────────────────────┘
+
+┌──────────────────────────────────────────────────────────────────┐
+│ With Context Mode                                                │
+│                                                                  │
+│ Claude Code → fetch_and_index(url)  → "Indexed 8 sections" (50B)│
+│ Claude Code → search("snapshot")    → exact element       (500B) │
+│ Claude Code → execute("gh pr list") → "3 open PRs"         (40B)│
+│ Claude Code → execute_file(log)     → "500:14, 404:89"     (30B)│
+│                                                                  │
+│ Total: 620B consumed = ~160 tokens = 0.08% of context            │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+## Architecture
+
+```
+┌─────────────┐    stdio / JSON-RPC     ┌──────────────────────────────┐
+│             │ ◄──────────────────────► │  Context Mode MCP Server     │
+│ Claude Code │    tool calls/results    │                              │
+│             │                          │  ┌────────────────────────┐  │
+└─────────────┘                          │  │ PolyglotExecutor       │  │
+                                         │  │ • 10 language runtimes │  │
+                                         │  │ • Sandboxed subprocess │  │
+                                         │  │ • Auth passthrough     │  │
+                                         │  │ • Smart truncation     │  │
+                                         │  └────────────────────────┘  │
+                                         │                              │
+                                         │  ┌────────────────────────┐  │
+                                         │  │ ContentStore           │  │
+                                         │  │ • SQLite FTS5          │  │
+                                         │  │ • BM25 ranking         │  │
+                                         │  │ • Porter stemming      │  │
+                                         │  │ • Heading-aware chunks │  │
+                                         │  └────────────────────────┘  │
+                                         └──────────────────────────────┘
+```
+
+### Sandbox Isolation
+
+Each `execute` call spawns an isolated subprocess with:
+
+- **Isolated temp directory** per execution — scripts can't access each other
+- **Real HOME** — so `gh`, `aws`, `gcloud` find their auth configs
+- **Auth passthrough** — GH_TOKEN, AWS credentials, KUBECONFIG, Docker, npm tokens, XDG paths
+- **Clean environment** — PATH, LANG, NO_COLOR, Python unbuffered mode
+
+### FTS5 Knowledge Base
+
+The `index` and `search` tools use SQLite FTS5 with BM25 ranking:
+
+```sql
+CREATE VIRTUAL TABLE chunks USING fts5(
+  title,                        -- heading hierarchy, weighted 2x
+  content,                      -- section text + code blocks
+  source_id UNINDEXED,
+  content_type UNINDEXED,       -- "code" or "prose"
+  tokenize='porter unicode61'   -- stemming + unicode support
+);
+
+SELECT title, content, bm25(chunks, 2.0, 1.0) AS rank
+FROM chunks
+WHERE chunks MATCH ?
+ORDER BY rank LIMIT 3;
+```
+
+**Chunking algorithm:**
+- Splits on H1-H4 headings and `---` separators
+- Tracks heading hierarchy: `"React > Hooks > useEffect > Cleanup"`
+- Keeps code blocks intact — never splits mid-block
+- Marks chunks as `code` or `prose` for content-type filtering
+- Porter stemming: "connecting" matches "connect", "connection", "connected"
+
+**Lazy singleton:** Database created only when `index` or `search` is first called — zero overhead for sessions that don't use it.
+
+### Smart Truncation
+
+When subprocess output exceeds the 100KB buffer, Context Mode preserves both head and tail:
+
+```
+Head (60%): Initial output with context
+... [47 lines / 3.2KB truncated — showing first 12 + last 8 lines] ...
+Tail (40%): Final output with errors/results
+```
+
+Line-boundary snapping — never cuts mid-line. Error messages at the bottom are always preserved.
+
+### HTML to Markdown Conversion
+
+`fetch_and_index` converts HTML in a subprocess (raw HTML never enters context):
+
+1. Strip `<script>`, `<style>`, `<nav>`, `<header>`, `<footer>`
+2. Convert `<h1>`-`<h4>` to `#`-`####` markdown headings
+3. Convert `<pre><code>` to fenced code blocks with language detection
+4. Convert `<a>`, `<li>`, `<p>`, `<br>`, `<hr>` to markdown
+5. Decode HTML entities (`&amp;`, `&lt;`, `&nbsp;`, etc.)
+6. Collapse excessive whitespace
+
+## Benchmarks
+
+### Real MCP Ecosystem Comparison
+
+Tested with tools from popular MCP servers and Claude Code workflows:
+
+| Scenario | Tool | Raw | Context | Savings |
+|---|---|---|---|---|
+| Playwright page snapshot | `execute_file` | 50+ KB | 78 B | **99%** |
+| Context7 React docs | `index + search` | 5.9 KB | 285 B | **95%** |
+| Context7 Supabase docs | `index + search` | 3.9 KB | 123 B | **97%** |
+| Context7 Next.js docs | `index + search` | 6.5 KB | 273 B | **96%** |
+| httpbin.org API docs | `fetch_and_index` | 9.4 KB | 50 B | **99%** |
+| GitHub API response | `execute` | 8+ KB | 40 B | **99%** |
+| Access log (500 req) | `execute_file` | 45.1 KB | 71 B | **100%** |
+| Analytics CSV (500 rows) | `execute_file` | 85.5 KB | 11.5 KB | **87%** |
+| MCP tools manifest (40 tools) | `execute_file` | 17.0 KB | 78 B | **100%** |
+| npm test (30 suites) | `execute_file` | 6.0 KB | 37 B | **99%** |
+| Git log (153 commits) | `execute` | 11.6 KB | 18 B | **100%** |
+
+### Session Impact
+
+Typical 45-minute debugging session:
+
+| Metric | Without | With | Delta |
+|---|---|---|---|
+| Context consumed | 177 KB | 10 KB | **-94%** |
+| Tokens used | ~45,300 | ~2,600 | **-94%** |
+| Context remaining | 77% | 95% | **+18pp** |
+| Time before slowdown | ~30 min | ~3 hours | **+6x** |
+
+## Tool Decision Matrix
+
+| Data Type | Best Tool | Why |
+|---|---|---|
+| Web documentation | `fetch_and_index` → `search` | Index once, search many times |
+| MCP tool output (large) | `index` → `search` | Keep raw output out of context |
+| Log files | `execute_file` | Aggregate stats |
+| Test output | `execute_file` | Pass/fail summary |
+| CSV / JSON data | `execute_file` | Computed metrics |
+| Git / GitHub operations | `execute` | `gh`, `git` commands with auth |
+| Cloud CLI | `execute` | `aws`, `gcloud`, `kubectl` with auth |
+| Build output | `execute` | Error counts and warnings |
+| Source code to edit | Plain `Read` tool | Need full content for edits |
+| Small files (<20 lines) | Plain `Read` tool | Minimal overhead |
+
+## Requirements
+
+- **Node.js 18+**
+- **Claude Code** with MCP support
+
+### Auto-Detected Runtimes
+
+| Runtime | Used For | Speed |
+|---|---|---|
+| Bun (optional) | JS/TS execution | 3-5x faster than Node |
+| Python 3 | Python code | Standard |
+| Ruby, Go, Rust, PHP, Perl, R | Respective languages | Standard |
+
+## Test Suite
+
+113 tests across 3 suites:
+
+| Suite | Tests | Coverage |
+|---|---|---|
+| Executor | 55 | 10 languages, sandbox, truncation, concurrency, timeouts |
+| ContentStore | 34 | FTS5 schema, BM25 ranking, chunking, stemming, fixtures |
+| MCP Integration | 24 | JSON-RPC protocol, all 5 tools, fetch_and_index, errors |
+
+## Development
+
+```bash
+git clone https://github.com/mksglu/claude-context-mode.git
+cd claude-context-mode
+npm install
+npm run build
+npm test              # executor (55 tests)
+npm run test:store    # FTS5/BM25 (34 tests)
+npm run test:all      # all suites (113 tests)
+```
+
+## License
+
+MIT

package/build/cli.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * context-mode CLI
+ *
+ * Usage:
+ *   context-mode          → Start MCP server (stdio)
+ *   context-mode setup    → Interactive setup (detect runtimes, install Bun)
+ *   context-mode doctor   → Diagnose runtime issues
+ */
+export {};

package/build/cli.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/**
+ * context-mode CLI
+ *
+ * Usage:
+ *   context-mode          → Start MCP server (stdio)
+ *   context-mode setup    → Interactive setup (detect runtimes, install Bun)
+ *   context-mode doctor   → Diagnose runtime issues
+ */
+import * as p from "@clack/prompts";
+import color from "picocolors";
+import { execSync } from "node:child_process";
+import { detectRuntimes, getRuntimeSummary, hasBunRuntime, getAvailableLanguages, } from "./runtime.js";
+const args = process.argv.slice(2);
+if (args[0] === "setup") {
+    setup();
+}
+else if (args[0] === "doctor") {
+    doctor();
+}
+else {
+    // Default: start MCP server
+    import("./server.js");
+}
+async function setup() {
+    console.clear();
+    p.intro(color.bgCyan(color.black(" context-mode setup ")));
+    const s = p.spinner();
+    // Step 1: Detect runtimes
+    s.start("Detecting installed runtimes");
+    const runtimes = detectRuntimes();
+    const available = getAvailableLanguages(runtimes);
+    s.stop("Detected " + available.length + " languages");
+    // Show what's available
+    p.note(getRuntimeSummary(runtimes), "Detected Runtimes");
+    // Step 2: Check Bun
+    if (!hasBunRuntime()) {
+        p.log.warn(color.yellow("Bun is not installed.") +
+            " JS/TS will run with Node.js (3-5x slower).");
+        const installBun = await p.confirm({
+            message: "Would you like to install Bun for faster execution?",
+            initialValue: true,
+        });
+        if (p.isCancel(installBun)) {
+            p.cancel("Setup cancelled.");
+            process.exit(0);
+        }
+        if (installBun) {
+            s.start("Installing Bun");
+            try {
+                execSync("curl -fsSL https://bun.sh/install | bash", {
+                    stdio: "pipe",
+                    timeout: 60000,
+                });
+                s.stop(color.green("Bun installed successfully!"));
+                // Re-detect runtimes
+                const newRuntimes = detectRuntimes();
+                if (hasBunRuntime()) {
+                    p.log.success("JavaScript and TypeScript will now use Bun " +
+                        color.dim("(3-5x faster)"));
+                }
+                p.note(getRuntimeSummary(newRuntimes), "Updated Runtimes");
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                s.stop(color.red("Failed to install Bun"));
+                p.log.error("Installation failed: " +
+                    message +
+                    "\nYou can install manually: curl -fsSL https://bun.sh/install | bash");
+                p.log.info(color.dim("Continuing with Node.js — everything will still work."));
+            }
+        }
+        else {
+            p.log.info(color.dim("No problem! Using Node.js. You can install Bun later: curl -fsSL https://bun.sh/install | bash"));
+        }
+    }
+    else {
+        p.log.success(color.green("Bun detected!") +
+            " JS/TS will run at maximum speed.");
+    }
+    // Step 3: Check optional runtimes
+    const missing = [];
+    if (!runtimes.python)
+        missing.push("Python (python3)");
+    if (!runtimes.ruby)
+        missing.push("Ruby (ruby)");
+    if (!runtimes.go)
+        missing.push("Go (go)");
+    if (!runtimes.php)
+        missing.push("PHP (php)");
+    if (!runtimes.r)
+        missing.push("R (Rscript)");
+    if (missing.length > 0) {
+        p.log.info(color.dim("Optional runtimes not found: " + missing.join(", ")));
+        p.log.info(color.dim("Install them to enable additional language support in context-mode."));
+    }
+    // Step 4: Installation instructions
+    const installMethod = await p.select({
+        message: "How would you like to configure context-mode?",
+        options: [
+            {
+                value: "claude-code",
+                label: "Claude Code (recommended)",
+                hint: "claude mcp add",
+            },
+            {
+                value: "manual",
+                label: "Show manual configuration",
+                hint: ".mcp.json",
+            },
+            { value: "skip", label: "Skip — I'll configure later" },
+        ],
+    });
+    if (p.isCancel(installMethod)) {
+        p.cancel("Setup cancelled.");
+        process.exit(0);
+    }
+    const serverPath = new URL("./server.js", import.meta.url).pathname;
+    if (installMethod === "claude-code") {
+        s.start("Adding to Claude Code");
+        try {
+            execSync(`claude mcp add context-mode -- node ${serverPath}`, { stdio: "pipe", timeout: 10000 });
+            s.stop(color.green("Added to Claude Code!"));
+        }
+        catch {
+            s.stop(color.yellow("Could not add automatically"));
+            p.log.info("Run manually:\n" +
+                color.cyan(`  claude mcp add context-mode -- node ${serverPath}`));
+        }
+    }
+    else if (installMethod === "manual") {
+        p.note(JSON.stringify({
+            mcpServers: {
+                "context-mode": {
+                    command: "node",
+                    args: [serverPath],
+                },
+            },
+        }, null, 2), "Add to your .mcp.json or Claude Code settings");
+    }
+    p.outro(color.green("Setup complete!") +
+        " " +
+        color.dim(available.length + " languages ready."));
+}
+async function doctor() {
+    console.clear();
+    p.intro(color.bgMagenta(color.white(" context-mode doctor ")));
+    const s = p.spinner();
+    s.start("Running diagnostics");
+    const runtimes = detectRuntimes();
+    const available = getAvailableLanguages(runtimes);
+    s.stop("Diagnostics complete");
+    // Runtime check
+    p.note(getRuntimeSummary(runtimes), "Runtimes");
+    // Speed tier
+    if (hasBunRuntime()) {
+        p.log.success(color.green("Performance: FAST") +
+            " — Bun detected for JS/TS execution");
+    }
+    else {
+        p.log.warn(color.yellow("Performance: NORMAL") +
+            " — Using Node.js (install Bun for 3-5x speed boost)");
+    }
+    // Language coverage
+    const total = 10;
+    const pct = ((available.length / total) * 100).toFixed(0);
+    p.log.info(`Language coverage: ${available.length}/${total} (${pct}%)` +
+        color.dim(` — ${available.join(", ")}`));
+    // Server test
+    p.log.step("Testing server initialization...");
+    try {
+        const { PolyglotExecutor } = await import("./executor.js");
+        const executor = new PolyglotExecutor({ runtimes });
+        const result = await executor.execute({
+            language: "javascript",
+            code: 'console.log("ok");',
+            timeout: 5000,
+        });
+        if (result.exitCode === 0 && result.stdout.trim() === "ok") {
+            p.log.success(color.green("Server test: PASS"));
+        }
+        else {
+            p.log.error(color.red("Server test: FAIL") + ` — exit ${result.exitCode}`);
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        p.log.error(color.red("Server test: FAIL") + ` — ${message}`);
+    }
+    p.outro(available.length >= 4
+        ? color.green("Everything looks good!")
+        : color.yellow("Some runtimes missing — install them for full coverage"));
+}

package/build/executor.d.ts

@@ -0,0 +1,27 @@
+import { type RuntimeMap, type Language } from "./runtime.js";
+export interface ExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut: boolean;
+}
+interface ExecuteOptions {
+    language: Language;
+    code: string;
+    timeout?: number;
+}
+interface ExecuteFileOptions extends ExecuteOptions {
+    path: string;
+}
+export declare class PolyglotExecutor {
+    #private;
+    constructor(opts?: {
+        maxOutputBytes?: number;
+        projectRoot?: string;
+        runtimes?: RuntimeMap;
+    });
+    get runtimes(): RuntimeMap;
+    execute(opts: ExecuteOptions): Promise<ExecResult>;
+    executeFile(opts: ExecuteFileOptions): Promise<ExecResult>;
+}
+export {};