@aria-cli/tools 1.0.19 → 1.0.31

package/dist-cjs/utils/retry.js

@@ -0,0 +1,170 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWithRetry = fetchWithRetry;
+exports.fetchWithSsrf = fetchWithSsrf;
+function createAbortError() {
+    const err = new Error("AbortError");
+    err.name = "AbortError";
+    return err;
+}
+/**
+ * AbortSignal-aware sleep that rejects immediately if the signal fires during the delay.
+ */
+function abortAwareSleep(ms, signal) {
+    if (signal?.aborted) {
+        return Promise.reject(createAbortError());
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let abortHandler;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            if (signal && abortHandler) {
+                signal.removeEventListener("abort", abortHandler);
+            }
+            resolve();
+        }, ms);
+        if (signal) {
+            abortHandler = () => {
+                if (settled)
+                    return;
+                settled = true;
+                signal.removeEventListener("abort", abortHandler);
+                clearTimeout(timer);
+                reject(createAbortError());
+            };
+            signal.addEventListener("abort", abortHandler, { once: true });
+        }
+    });
+}
+function isAbortError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const domErr = err;
+    return domErr.name === "AbortError" || err.message === "AbortError";
+}
+function getErrorCode(err) {
+    if (typeof err === "object" &&
+        err !== null &&
+        "code" in err &&
+        typeof err.code === "string") {
+        return err.code;
+    }
+    if (err instanceof Error && err.cause) {
+        const cause = err.cause;
+        if (typeof cause.code === "string") {
+            return cause.code;
+        }
+    }
+    return undefined;
+}
+async function fetchWithRetry(url, init, options) {
+    const maxAttempts = options?.maxAttempts ?? 3;
+    const baseDelayMs = options?.baseDelayMs ?? 1000;
+    const maxDelayMs = options?.maxDelayMs ?? 30000;
+    const retryableStatuses = options?.retryableStatuses ?? [429, 500, 502, 503, 504];
+    const retryableCodes = options?.retryableCodes ?? [
+        "ECONNRESET",
+        "ETIMEDOUT",
+        "EPIPE",
+        "ENETUNREACH",
+        "EHOSTUNREACH",
+        "ECONNREFUSED",
+        "EAI_AGAIN",
+        "UND_ERR_CONNECT_TIMEOUT",
+        "UND_ERR_SOCKET",
+    ];
+    const doFetch = options?.fetchFn ?? fetch;
+    const signal = init.signal ?? null;
+    if (signal?.aborted) {
+        throw createAbortError();
+    }
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            const response = await doFetch(url, init);
+            // Check for Cloudflare 403 challenge
+            if (response.status === 403 && response.headers.get("cf-mitigated") === "challenge") {
+                if (attempt < maxAttempts - 1) {
+                    // Retry with simplified UA
+                    const delay = Math.min(baseDelayMs * 2 ** attempt + Math.random() * 500, maxDelayMs);
+                    await abortAwareSleep(delay, signal);
+                    continue;
+                }
+                // Last attempt - throw
+                throw new Error(`Cloudflare challenge after ${maxAttempts} attempts: ${response.status}`);
+            }
+            // Check for retryable status codes
+            if (!response.ok && retryableStatuses.includes(response.status)) {
+                if (attempt < maxAttempts - 1) {
+                    const delay = Math.min(baseDelayMs * 2 ** attempt + Math.random() * 500, maxDelayMs);
+                    await abortAwareSleep(delay, signal);
+                    continue;
+                }
+                // Last attempt - throw
+                throw new Error(`Request failed after ${maxAttempts} attempts: ${response.status}`);
+            }
+            return response;
+        }
+        catch (err) {
+            // Re-throw AbortError immediately — do not retry aborted requests
+            if (isAbortError(err)) {
+                throw err;
+            }
+            const code = getErrorCode(err);
+            if (code && retryableCodes.includes(code) && attempt < maxAttempts - 1) {
+                const delay = Math.min(baseDelayMs * 2 ** attempt + Math.random() * 500, maxDelayMs);
+                await abortAwareSleep(delay, signal);
+                continue;
+            }
+            lastError = err;
+            throw err;
+        }
+    }
+    throw lastError ?? new Error("fetchWithRetry: unreachable");
+}
+async function fetchWithSsrf(url, init, retryOptions) {
+    const { fetchWithDnsPinning } = await Promise.resolve().then(() => __importStar(require("../security/dns-pinning.js")));
+    return fetchWithRetry(url, init, {
+        ...retryOptions,
+        fetchFn: async (attemptUrl, attemptInit) => {
+            return fetchWithDnsPinning(attemptUrl, attemptInit);
+        },
+    });
+}
+//# sourceMappingURL=retry.js.map

package/dist-cjs/utils/safe-parse-json.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Safe JSON extraction and parsing utilities for LLM output.
+ *
+ * Handles code fences, preamble text, bare JSON, and validates against Zod schemas.
+ * NEVER throws -- always returns a typed Result.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractJson = extractJson;
+exports.safeParseJson = safeParseJson;
+const MAX_SCAN_CHARS = 12_000;
+const MAX_JSON_CANDIDATES = 16;
+function isJsonRootStart(char) {
+    return char === "{" || char === "[";
+}
+/**
+ * Find the end index of a balanced JSON root (object/array) starting at `start`.
+ * Returns -1 when no balanced root can be found.
+ */
+function findBalancedJsonEnd(input, start) {
+    if (start < 0 || start >= input.length)
+        return -1;
+    const first = input[start];
+    if (!isJsonRootStart(first))
+        return -1;
+    const stack = [];
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < input.length; i++) {
+        const char = input[i];
+        if (!char)
+            continue;
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === "{" || char === "[") {
+            stack.push(char);
+            continue;
+        }
+        if (char === "}" || char === "]") {
+            const opener = stack.pop();
+            if (!opener)
+                return -1;
+            if ((opener === "{" && char !== "}") || (opener === "[" && char !== "]")) {
+                return -1;
+            }
+            if (stack.length === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function collectJsonCandidates(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    const seen = new Set();
+    const candidates = [];
+    const add = (candidate) => {
+        if (candidates.length >= MAX_JSON_CANDIDATES)
+            return;
+        const value = candidate.trim();
+        if (!value || !isJsonRootStart(value[0] ?? ""))
+            return;
+        if (seen.has(value))
+            return;
+        seen.add(value);
+        candidates.push(value);
+    };
+    const collectFromText = (text) => {
+        const bounded = text.slice(0, MAX_SCAN_CHARS);
+        for (let i = 0; i < bounded.length && candidates.length < MAX_JSON_CANDIDATES; i++) {
+            const char = bounded[i];
+            if (!char || !isJsonRootStart(char))
+                continue;
+            const end = findBalancedJsonEnd(bounded, i);
+            if (end === -1)
+                continue;
+            add(bounded.slice(i, end + 1));
+            i = end;
+        }
+    };
+    // 1) Prefer explicit code-fence blocks first.
+    const fenceRegex = /```(?:json|JSON)?\s*\n?([\s\S]*?)```/g;
+    for (const match of trimmed.matchAll(fenceRegex)) {
+        const fenced = match[1]?.trim();
+        if (!fenced)
+            continue;
+        if (isJsonRootStart(fenced[0] ?? "")) {
+            add(fenced);
+        }
+        else {
+            collectFromText(fenced);
+        }
+        if (candidates.length >= MAX_JSON_CANDIDATES)
+            break;
+    }
+    // 2) Full-text scan (handles preamble + trailing text + multiple snippets).
+    if (candidates.length < MAX_JSON_CANDIDATES) {
+        if (isJsonRootStart(trimmed[0] ?? "")) {
+            add(trimmed);
+        }
+        collectFromText(trimmed);
+    }
+    return candidates;
+}
+/**
+ * Extract JSON substring from LLM output.
+ * Returns the first candidate found by robust balanced scanning.
+ */
+function extractJson(raw) {
+    return collectJsonCandidates(raw)[0] ?? null;
+}
+/**
+ * Safely extract and parse JSON from LLM output with Zod validation.
+ * Handles code fences, preamble text, bare JSON.
+ * NEVER throws -- always returns a typed Result.
+ */
+function safeParseJson(raw, schema) {
+    const candidates = collectJsonCandidates(raw);
+    if (candidates.length === 0) {
+        return { ok: false, reason: "no_json", raw };
+    }
+    let parseErrorRaw = null;
+    let schemaMismatchRaw = null;
+    for (const jsonStr of candidates) {
+        let parsed;
+        try {
+            parsed = JSON.parse(jsonStr);
+        }
+        catch {
+            parseErrorRaw = jsonStr;
+            continue;
+        }
+        const validated = schema.safeParse(parsed);
+        if (validated.success) {
+            return { ok: true, data: validated.data };
+        }
+        schemaMismatchRaw = jsonStr;
+    }
+    if (schemaMismatchRaw) {
+        return { ok: false, reason: "schema_mismatch", raw: schemaMismatchRaw };
+    }
+    if (parseErrorRaw) {
+        return { ok: false, reason: "parse_error", raw: parseErrorRaw };
+    }
+    return { ok: false, reason: "no_json", raw };
+}
+//# sourceMappingURL=safe-parse-json.js.map

package/dist-cjs/utils/url.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeGitHubUrl = normalizeGitHubUrl;
+exports.getUserAgent = getUserAgent;
+/**
+ * Convert GitHub blob URLs to raw.githubusercontent.com URLs.
+ * GitHub blob URLs return HTML wrappers; raw URLs return actual file content.
+ */
+function normalizeGitHubUrl(url) {
+    const match = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/(.+)$/);
+    if (match) {
+        return `https://raw.githubusercontent.com/${match[1]}/${match[2]}/${match[3]}`;
+    }
+    return url;
+}
+/**
+ * Get configurable User-Agent string.
+ * Reads from ARIA_USER_AGENT env var, falls back to default.
+ */
+function getUserAgent() {
+    const DEFAULT_UA = `Mozilla/5.0 (compatible; ARIA/1.0.0; +https://github.com/aria)`;
+    return process.env.ARIA_USER_AGENT ?? DEFAULT_UA;
+}
+//# sourceMappingURL=url.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aria-cli/tools",
-  "version": "1.0.19",
+  "version": "1.0.31",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,24 +19,23 @@
   "scripts": {
     "dev": "tsc --watch",
     "test": "vitest run --config vitest.config.ts",
-    "test:list": "tsx tests/print-default-test-lane.ts",
+    "test:list": "bun tests/print-default-test-lane.ts",
     "test:watch": "vitest --config vitest.config.ts",
     "test:integration": "vitest run --config vitest.integration.config.ts",
     "test:native": "vitest run --config vitest.native.config.ts",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
-    "test:lanes": "tsx tests/print-test-lane-manifest.ts"
+    "test:lanes": "bun tests/print-test-lane-manifest.ts"
   },
   "//dependencies": "TODO: @aria/memoria for ToolContext typing, @aria/types for shared types - needed for future tool execution context",
   "dependencies": {
-    "@aria-cli/fastripgrep": "1.0.19",
-    "@aria-cli/search": "1.0.19",
-    "@aria-cli/types": "1.0.19",
+    "@aria-cli/fastripgrep": "1.0.31",
+    "@aria-cli/search": "1.0.31",
+    "@aria-cli/types": "1.0.31",
     "@mozilla/readability": "^0.6.0",
     "diff": "^8.0.3",
     "fast-glob": "^3.3.3",
     "jsdom": "^28.1.0",
     "nanoid": "^5.1.6",
-    "node-pty": "^1.1.0",
     "playwright": "^1.58.2",
     "turndown": "^7.2.2",
     "undici": "^7.22.0",
@@ -44,10 +43,10 @@
     "zod": "^4.3.6"
   },
   "optionalDependencies": {
-    "@aria-cli/cli": "1.0.19"
+    "@aria-cli/cli": "1.0.31"
   },
   "devDependencies": {
-    "@aria-cli/memoria": "1.0.19",
+    "@aria-cli/memoria": "1.0.29",
     "@types/jsdom": "^28.0.0",
     "@types/json-schema": "^7.0.15",
     "@types/turndown": "^5.0.6",
@@ -58,7 +57,9 @@
     "dist/",
     "dist-cjs/",
     "!**/*.map",
-    "!**/*.tsbuildinfo"
+    "!**/*.tsbuildinfo",
+    "!**/*.d.ts",
+    "!**/*.d.ts.map"
   ],
   "engines": {
     "node": ">=20.0.0"

package/dist/ask-user-interaction.d.ts

@@ -1,10 +0,0 @@
-export interface AskUserQuestion {
-    question: string;
-    options?: string[];
-}
-export declare class AskUserPauseRequiredError extends Error {
-    readonly code: "ASK_USER_PAUSE_REQUIRED";
-    readonly questions: AskUserQuestion[];
-    constructor(questions: AskUserQuestion[], message?: string);
-}
-export declare function isAskUserPauseRequiredError(error: unknown): error is AskUserPauseRequiredError;

package/dist/cache/web-cache.d.ts

@@ -1,52 +0,0 @@
-export declare class WebCache<T> {
-    private maxEntries;
-    private ttlMs;
-    private cache;
-    private setCallCount;
-    /** How often to run proactive eviction (every N set() calls) */
-    private static readonly EVICTION_INTERVAL;
-    constructor(maxEntries?: number, ttlMs?: number);
-    get(key: string): T | undefined;
-    set(key: string, value: T): void;
-    /**
-     * Proactively remove all expired entries from the cache.
-     * Called periodically from set() to prevent expired entries from
-     * consuming memory until they are accessed or evicted by LRU.
-     */
-    evictExpired(): void;
-    /** Remove all entries from the cache */
-    clear(): void;
-    /** Current number of entries in the cache */
-    get size(): number;
-}
-import type { SearchResult } from "../providers/search-provider.js";
-/** Cached search output: query + results array */
-export interface CachedSearchOutput {
-    query: string;
-    results: SearchResult[];
-}
-/** Cached fetch output with metadata */
-export interface CachedFetchOutput {
-    content: unknown;
-    status: number;
-    contentType?: string;
-    fromCache: boolean;
-    fetchedAt: string;
-    finalUrl: string;
-    contentBytes: number;
-    truncated: boolean;
-}
-/** Cached browse output with metadata */
-export interface CachedBrowseOutput {
-    url: string;
-    title: string;
-    content: string;
-    fromCache: boolean;
-    fetchedAt: string;
-    finalUrl: string;
-    contentBytes: number;
-    truncated: boolean;
-}
-export declare const searchCache: WebCache<CachedSearchOutput>;
-export declare const fetchCache: WebCache<CachedFetchOutput>;
-export declare const browseCache: WebCache<CachedBrowseOutput>;

package/dist/definitions/arion.d.ts

@@ -1,8 +0,0 @@
-/**
- * Arion tool definitions
- *
- * Tools: hatch_arion, rest_arion, wake_arion, retire_arion (4 tools)
- */
-import type { Tool } from "../types.js";
-/** Arion tool definitions (4) */
-export declare const ARION_TOOL_DEFINITIONS: Tool[];

package/dist/definitions/browser/browser.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from "../../types.js";
-export declare const browserTool: Tool;

package/dist/definitions/browser/index.d.ts

@@ -1 +0,0 @@
-export { browserTool } from "./browser.js";

package/dist/definitions/browser/pw-downloads.d.ts

@@ -1,13 +0,0 @@
-import type { PwPage } from "./types.js";
-/**
- * Wait for the next download event on the page and save the file.
- */
-export declare function waitForDownload(opts: {
-    page: PwPage;
-    path?: string;
-    timeoutMs?: number;
-}): Promise<{
-    url: string;
-    suggestedFilename: string;
-    path: string;
-}>;

package/dist/definitions/browser/pw-interactions.d.ts

@@ -1,78 +0,0 @@
-/**
- * Playwright interaction handlers: click, type, hover, drag, select, key press, evaluate.
- * Ported from OpenClaw's pw-tools-core.interactions.ts.
- */
-import type { PwPage, RoleRefMap } from "./types.js";
-/**
- * Resolve a ref string (e.g. "e1") into a Playwright Locator using the
- * role-ref map from the last snapshot.
- */
-export declare function refLocator(page: PwPage, ref: string, refs: RoleRefMap): import("./types.js").PwLocator;
-export declare function clickViaPlaywright(opts: {
-    page: PwPage;
-    refs: RoleRefMap;
-    ref: string;
-    doubleClick?: boolean;
-    button?: "left" | "right" | "middle";
-    modifiers?: string[];
-    timeoutMs?: number;
-}): Promise<void>;
-export declare function hoverViaPlaywright(opts: {
-    page: PwPage;
-    refs: RoleRefMap;
-    ref: string;
-    timeoutMs?: number;
-}): Promise<void>;
-export declare function dragViaPlaywright(opts: {
-    page: PwPage;
-    refs: RoleRefMap;
-    startRef: string;
-    endRef: string;
-    timeoutMs?: number;
-}): Promise<void>;
-export declare function typeViaPlaywright(opts: {
-    page: PwPage;
-    refs: RoleRefMap;
-    ref: string;
-    text: string;
-    submit?: boolean;
-    slowly?: boolean;
-    timeoutMs?: number;
-}): Promise<void>;
-export declare function selectOptionViaPlaywright(opts: {
-    page: PwPage;
-    refs: RoleRefMap;
-    ref: string;
-    values: string[];
-    timeoutMs?: number;
-}): Promise<void>;
-export declare function pressKeyViaPlaywright(opts: {
-    page: PwPage;
-    key: string;
-}): Promise<void>;
-export declare function evaluateViaPlaywright(opts: {
-    page: PwPage;
-    script: string;
-    timeoutMs?: number;
-}): Promise<unknown>;
-export declare function takeScreenshot(opts: {
-    page: PwPage;
-    fullPage?: boolean;
-}): Promise<Buffer>;
-export declare function scrollPage(opts: {
-    page: PwPage;
-    direction: "up" | "down";
-    amount?: number;
-}): Promise<void>;
-export declare function waitForCondition(opts: {
-    page: PwPage;
-    selector?: string;
-    text?: string;
-    timeout?: number;
-}): Promise<void>;
-export declare function uploadFiles(opts: {
-    page: PwPage;
-    refs: RoleRefMap;
-    ref: string;
-    paths: string[];
-}): Promise<void>;

package/dist/definitions/browser/pw-responses.d.ts

@@ -1,28 +0,0 @@
-/**
- * Console, network, and error monitoring.
- * Ported from OpenClaw's pw-tools-core.activity.ts + pw-tools-core.responses.ts.
- */
-import type { BrowserConsoleMessage, BrowserNetworkRequest, BrowserPageError } from "./types.js";
-export declare const MAX_CONSOLE_MESSAGES = 500;
-export declare const MAX_NETWORK_REQUESTS = 500;
-export declare const MAX_PAGE_ERRORS = 200;
-/**
- * Filter console messages by minimum severity level.
- */
-export declare function filterConsoleMessages(messages: BrowserConsoleMessage[], level?: string): BrowserConsoleMessage[];
-/**
- * Filter network requests by URL substring match.
- */
-export declare function filterNetworkRequests(requests: BrowserNetworkRequest[], filter?: string): BrowserNetworkRequest[];
-/**
- * Format console messages for tool output.
- */
-export declare function formatConsoleMessages(messages: BrowserConsoleMessage[]): string;
-/**
- * Format network requests for tool output.
- */
-export declare function formatNetworkRequests(requests: BrowserNetworkRequest[]): string;
-/**
- * Format page errors for tool output.
- */
-export declare function formatPageErrors(errors: BrowserPageError[]): string;

package/dist/definitions/browser/pw-session.d.ts

@@ -1,65 +0,0 @@
-/**
- * Browser session lifecycle management.
- * Unlike OpenClaw (which connects to an external Chrome via CDP), ARIA
- * launches its own Playwright browser instance directly.
- */
-import type { BrowserConsoleMessage, BrowserNetworkRequest, BrowserPageError, BrowserSession, PwBrowser, RoleRefMap } from "./types.js";
-export declare function getSession(): BrowserSession | null;
-export declare function getRefs(): RoleRefMap;
-export declare function setRefs(refs: RoleRefMap): void;
-export declare function getConsoleMessages(): BrowserConsoleMessage[];
-export declare function getNetworkRequests(): BrowserNetworkRequest[];
-export declare function getPageErrors(): BrowserPageError[];
-/**
- * Test seam for injecting a mocked playwright loader.
- * Passing null restores the production loader.
- */
-export declare function setPlaywrightLoaderForTest(loader: (() => Promise<unknown>) | null): void;
-type ChromiumLike = {
-    launch: (options?: {
-        headless?: boolean;
-    }) => Promise<PwBrowser>;
-};
-/**
- * Resolve Playwright's chromium launcher across module interop shapes.
- * Some runtimes expose `{ chromium }`, others only `{ default: { chromium } }`.
- */
-export declare function resolveChromiumLauncher(moduleValue: unknown): ChromiumLike;
-/**
- * Launch a new Playwright browser session.
- * Uses dynamic import so the tool module loads even without playwright installed.
- */
-export declare function launchBrowser(options?: {
-    headless?: boolean;
-    url?: string;
-}): Promise<BrowserSession>;
-/**
- * Close the current browser session and clean up all state.
- */
-export declare function closeBrowser(): Promise<void>;
-/**
- * List all open tabs (pages) in the current context.
- */
-export declare function listTabs(): Array<{
-    index: number;
-    url: string;
-    active: boolean;
-}>;
-/**
- * Open a new tab, optionally navigating to a URL.
- */
-export declare function newTab(url?: string): Promise<{
-    index: number;
-    url: string;
-}>;
-/**
- * Switch to a tab by index.
- */
-export declare function selectTab(index: number): Promise<{
-    url: string;
-}>;
-/**
- * Close a tab by index (defaults to current tab).
- */
-export declare function closeTab(index?: number): Promise<void>;
-export {};