browsirai 0.1.1 → 0.2.1

package/dist/cli/commands/nav.js

@@ -0,0 +1,739 @@
+// src/cli/run.ts
+import pc from "picocolors";
+
+// src/chrome-launcher.ts
+import { execSync, spawn } from "child_process";
+import { existsSync, readFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import http from "http";
+import { join } from "path";
+import { homedir, tmpdir } from "os";
+import { createConnection } from "net";
+
+// src/cli/run.ts
+function parseFlags(args) {
+  const flags = {};
+  let positionalIndex = 0;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        const key = arg.slice(2, eqIdx);
+        const value = arg.slice(eqIdx + 1);
+        flags[key] = value;
+      } else {
+        const key = arg.slice(2);
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = "true";
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1 && !/^-\d/.test(arg)) {
+      const chars = arg.slice(1);
+      if (chars.length === 1) {
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[chars] = next;
+          i++;
+        } else {
+          flags[chars] = "true";
+        }
+      } else {
+        for (const ch of chars) {
+          flags[ch] = "true";
+        }
+      }
+    } else {
+      flags[`_${positionalIndex}`] = arg;
+      positionalIndex++;
+    }
+  }
+  return flags;
+}
+function printResult(data) {
+  if (data === void 0 || data === null) return;
+  if (typeof data === "string") {
+    console.log(data);
+  } else if (typeof data === "object") {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(String(data));
+  }
+}
+
+// src/tools/browser-navigate.ts
+var POLL_INTERVAL_MS = 100;
+async function browserNavigate(cdp, params) {
+  const { url, timeout = 8 } = params;
+  const timeoutMs = timeout * 1e3;
+  await cdp.send("Page.enable");
+  const result = await Promise.race([
+    performNavigation(cdp, url, params.waitUntil),
+    createTimeout(timeoutMs)
+  ]);
+  return result;
+}
+async function performNavigation(cdp, url, waitUntil) {
+  const navResponse = await cdp.send("Page.navigate", { url });
+  if (navResponse.errorText) {
+    throw new Error(`Navigation failed: ${navResponse.errorText}`);
+  }
+  const hasCrossDocNavigation = Boolean(navResponse.loaderId);
+  if (hasCrossDocNavigation) {
+    await waitForLoadCompletion(cdp, waitUntil);
+  }
+  return getPageInfo(cdp);
+}
+function waitForLoadCompletion(cdp, waitUntil) {
+  const eventName = waitUntil === "domcontentloaded" ? "Page.domContentEventFired" : "Page.loadEventFired";
+  return new Promise((resolve) => {
+    let settled = false;
+    const handler = () => {
+      if (settled) return;
+      settled = true;
+      cdp.off(eventName, handler);
+      resolve();
+    };
+    cdp.on(eventName, handler);
+    const poll = async () => {
+      while (!settled) {
+        try {
+          const response = await cdp.send("Runtime.evaluate", {
+            expression: "document.readyState",
+            returnByValue: true
+          });
+          const readyState = response.result.value;
+          const isLoadingState = readyState === "loading" || readyState === "interactive";
+          if (readyState === "complete" || !isLoadingState) {
+            if (!settled) {
+              settled = true;
+              cdp.off(eventName, handler);
+              resolve();
+            }
+            return;
+          }
+        } catch {
+        }
+        if (!settled) {
+          await delay(POLL_INTERVAL_MS);
+        }
+      }
+    };
+    poll();
+  });
+}
+async function getPageInfo(cdp) {
+  const [titleResponse, urlResponse] = await Promise.all([
+    cdp.send("Runtime.evaluate", {
+      expression: "document.title"
+    }),
+    cdp.send("Runtime.evaluate", {
+      expression: "location.href"
+    })
+  ]);
+  return {
+    title: titleResponse.result.value ?? "",
+    url: urlResponse.result.value ?? ""
+  };
+}
+function createTimeout(ms) {
+  return new Promise((_resolve, reject) => {
+    setTimeout(() => {
+      reject(new Error(`Navigation timeout after ${ms}ms`));
+    }, ms);
+  });
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/tools/browser-navigate-back.ts
+async function browserNavigateBack(cdp, params) {
+  const direction = params.direction ?? "back";
+  const history = await cdp.send("Page.getNavigationHistory");
+  const targetIndex = direction === "back" ? history.currentIndex - 1 : history.currentIndex + 1;
+  if (targetIndex < 0 || targetIndex >= history.entries.length) {
+    return { success: false, url: history.entries[history.currentIndex]?.url };
+  }
+  const entry = history.entries[targetIndex];
+  await cdp.send("Page.navigateToHistoryEntry", { entryId: entry.id });
+  return { success: true, url: entry.url };
+}
+
+// src/tools/browser-scroll.ts
+var DEFAULT_SCROLL_AMOUNT = 300;
+async function resolveSelector(cdp, selector) {
+  const evalResult = await cdp.send("Runtime.evaluate", {
+    expression: `document.querySelector(${JSON.stringify(selector)})`,
+    returnByValue: false
+  });
+  if (evalResult.result.objectId && evalResult.result.subtype !== "null") {
+    return { objectId: evalResult.result.objectId };
+  }
+  if (evalResult.result.subtype === "null" || evalResult.result.value === null) {
+    throw new Error(`Element not found: ${selector}`);
+  }
+  try {
+    const resolveResponse = await cdp.send("DOM.resolveNode", {
+      backendNodeId: void 0
+    });
+    if (resolveResponse.object?.objectId) {
+      return { objectId: resolveResponse.object.objectId };
+    }
+  } catch {
+  }
+  throw new Error(`Could not find element: ${selector}`);
+}
+async function browserScroll(cdp, params) {
+  const { direction, selector } = params;
+  const amount = params.amount ?? DEFAULT_SCROLL_AMOUNT;
+  if (selector && !direction) {
+    const { objectId } = await resolveSelector(cdp, selector);
+    await cdp.send("Runtime.callFunctionOn", {
+      objectId,
+      functionDeclaration: `function() { this.scrollIntoView({ behavior: "smooth", block: "center" }); }`,
+      returnByValue: true
+    });
+    return { success: true };
+  }
+  if (selector && direction) {
+    const { objectId } = await resolveSelector(cdp, selector);
+    const scrollX2 = direction === "left" ? -amount : direction === "right" ? amount : 0;
+    const scrollY2 = direction === "up" ? -amount : direction === "down" ? amount : 0;
+    await cdp.send("Runtime.callFunctionOn", {
+      objectId,
+      functionDeclaration: `function() { this.scrollBy(${scrollX2}, ${scrollY2}); }`,
+      returnByValue: true
+    });
+    return { success: true };
+  }
+  const scrollX = direction === "left" ? -amount : direction === "right" ? amount : 0;
+  const scrollY = direction === "up" ? -amount : direction === "down" ? amount : 0;
+  await cdp.send("Runtime.evaluate", {
+    expression: `window.scrollBy(${scrollX}, ${scrollY})`,
+    returnByValue: true
+  });
+  return { success: true };
+}
+
+// src/tools/browser-wait-for.ts
+var DEFAULT_TIMEOUT_S = 30;
+var POLL_INTERVAL_MS2 = 100;
+function normalizeTimeoutMs(timeout) {
+  if (timeout > 60) {
+    return timeout;
+  }
+  return timeout * 1e3;
+}
+async function browserWaitFor(cdp, params) {
+  const timeoutMs = normalizeTimeoutMs(params.timeout ?? DEFAULT_TIMEOUT_S);
+  const start = Date.now();
+  if (params.time !== void 0) {
+    const delayMs = params.time * 1e3;
+    await delay2(delayMs);
+    return { success: true, elapsed: Date.now() - start };
+  }
+  const condition = buildCondition(params);
+  while (true) {
+    const elapsed = Date.now() - start;
+    if (elapsed >= timeoutMs) {
+      throw new Error(
+        `Timeout after ${timeoutMs}ms waiting for condition: ${describeCondition(params)}`
+      );
+    }
+    let met = false;
+    try {
+      met = await evaluateCondition(cdp, condition);
+    } catch {
+    }
+    if (met) {
+      return { success: true, elapsed: Date.now() - start };
+    }
+    await delay2(POLL_INTERVAL_MS2);
+  }
+}
+function buildCondition(params) {
+  if (params.url !== void 0) {
+    return { kind: "url", expression: params.url };
+  }
+  if (params.fn !== void 0) {
+    return {
+      kind: "fn",
+      expression: `Boolean(${params.fn})`
+    };
+  }
+  if (params.selector !== void 0 && params.state === "hidden") {
+    return {
+      kind: "selectorHidden",
+      expression: buildVisibilityCheck(params.selector)
+    };
+  }
+  if (params.selector !== void 0 && params.visible) {
+    return {
+      kind: "selectorVisible",
+      expression: buildVisibilityCheck(params.selector)
+    };
+  }
+  if (params.selector !== void 0) {
+    return {
+      kind: "selector",
+      expression: `document.querySelector(${JSON.stringify(params.selector)})`
+    };
+  }
+  if (params.text !== void 0) {
+    return {
+      kind: "text",
+      expression: `document.body && document.body.innerText.includes(${JSON.stringify(params.text)})`
+    };
+  }
+  if (params.textGone !== void 0) {
+    return {
+      kind: "textGone",
+      expression: `document.body && !document.body.innerText.includes(${JSON.stringify(params.textGone)})`
+    };
+  }
+  if (params.networkIdle) {
+    return {
+      kind: "networkIdle",
+      expression: "true"
+      // Simplified: check via Runtime.evaluate
+    };
+  }
+  if (params.loadState !== void 0) {
+    return {
+      kind: "loadState",
+      expression: params.loadState
+    };
+  }
+  if (params.load) {
+    return {
+      kind: "load",
+      expression: "document.readyState"
+    };
+  }
+  throw new Error("browserWaitFor: no wait condition specified");
+}
+function buildVisibilityCheck(selector) {
+  const sel = JSON.stringify(selector);
+  return `(function() {
+    var el = document.querySelector(${sel});
+    if (!el) return false;
+    var style = window.getComputedStyle(el);
+    return style.display !== 'none' && style.visibility !== 'hidden' && el.offsetParent !== null;
+  })()`;
+}
+async function evaluateCondition(cdp, condition) {
+  if (condition.kind === "url") {
+    return evaluateUrlCondition(cdp, condition.expression);
+  }
+  if (condition.kind === "load") {
+    return evaluateLoadCondition(cdp, condition.expression);
+  }
+  if (condition.kind === "loadState") {
+    return evaluateLoadStateCondition(cdp, condition.expression);
+  }
+  if (condition.kind === "selectorHidden") {
+    const response2 = await cdp.send("Runtime.evaluate", {
+      expression: condition.expression,
+      returnByValue: true
+    });
+    return response2.result.value === false;
+  }
+  if (condition.kind === "selector") {
+    const response2 = await cdp.send("Runtime.evaluate", {
+      expression: condition.expression,
+      returnByValue: true
+    });
+    return response2.result.value !== null && response2.result.subtype !== "null";
+  }
+  const response = await cdp.send("Runtime.evaluate", {
+    expression: condition.expression,
+    returnByValue: true
+  });
+  return response.result.value === true;
+}
+async function evaluateLoadCondition(cdp, expression) {
+  const response = await cdp.send("Runtime.evaluate", {
+    expression,
+    returnByValue: true
+  });
+  if (response.result.type === "string") {
+    return response.result.value === "complete";
+  }
+  return response.result.value === true;
+}
+async function evaluateLoadStateCondition(cdp, targetState) {
+  const response = await cdp.send("Runtime.evaluate", {
+    expression: "document.readyState",
+    returnByValue: true
+  });
+  const current = response.result.value;
+  if (targetState === "complete") {
+    return current === "complete";
+  }
+  if (targetState === "interactive") {
+    return current === "interactive" || current === "complete";
+  }
+  return current === targetState;
+}
+async function evaluateUrlCondition(cdp, pattern) {
+  const response = await cdp.send("Runtime.evaluate", {
+    expression: "location.href",
+    returnByValue: true
+  });
+  const currentUrl = response.result.value;
+  return globMatch(pattern, currentUrl);
+}
+function globMatch(pattern, value) {
+  const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\u0000/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(regexStr);
+  return regex.test(value);
+}
+function describeCondition(params) {
+  if (params.text) return `text "${params.text}" to appear`;
+  if (params.textGone) return `text "${params.textGone}" to disappear`;
+  if (params.selector && params.state === "hidden")
+    return `selector "${params.selector}" to become hidden`;
+  if (params.selector && params.visible)
+    return `selector "${params.selector}" to become visible`;
+  if (params.selector) return `selector "${params.selector}" to appear`;
+  if (params.url) return `URL matching "${params.url}"`;
+  if (params.fn) return `JS condition: ${params.fn}`;
+  if (params.loadState) return `document.readyState === "${params.loadState}"`;
+  if (params.networkIdle) return "network idle";
+  if (params.load) return "page load complete";
+  return "unknown condition";
+}
+function delay2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/tools/browser-close.ts
+async function browserClose(cdp, params) {
+  let closedCount = 0;
+  if (params.closeAll) {
+    const targetsResponse = await cdp.send("Target.getTargets");
+    const pageTargets = targetsResponse.targetInfos.filter(
+      (t) => t.type === "page"
+    );
+    for (const target of pageTargets) {
+      try {
+        await cdp.send("Target.closeTarget", {
+          targetId: target.targetId
+        });
+        closedCount++;
+      } catch {
+      }
+    }
+  } else if (params.targetId) {
+    await cdp.send("Target.closeTarget", {
+      targetId: params.targetId
+    });
+    closedCount = 1;
+  } else {
+    const targetsResponse = await cdp.send("Target.getTargets");
+    const pageTargets = targetsResponse.targetInfos.filter(
+      (t) => t.type === "page"
+    );
+    if (pageTargets.length === 0) {
+      throw new Error("No page targets found to close");
+    }
+    const activeTarget = pageTargets.find((t) => t.attached) ?? pageTargets[0];
+    await cdp.send("Target.closeTarget", {
+      targetId: activeTarget.targetId
+    });
+    closedCount = 1;
+  }
+  return {
+    success: true,
+    closedTargets: closedCount
+  };
+}
+
+// src/tools/browser-tabs.ts
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const regexStr = escaped.replace(/\*/g, ".*");
+  return new RegExp(`^${regexStr}$`, "i");
+}
+async function browserTabs(cdp, params = {}) {
+  const response = await cdp.send("Target.getTargets");
+  let tabs2 = response.targetInfos.filter(
+    (target) => target.type === "page"
+  );
+  if (params.filter) {
+    const regex = globToRegExp(params.filter);
+    tabs2 = tabs2.filter((target) => regex.test(target.url));
+  }
+  return {
+    tabs: tabs2.map((target) => ({
+      id: target.targetId,
+      title: target.title,
+      url: target.url
+    }))
+  };
+}
+
+// src/tools/browser-resize.ts
+var PRESETS = {
+  mobile: { width: 375, height: 667 },
+  tablet: { width: 768, height: 1024 },
+  desktop: { width: 1280, height: 720 },
+  fullhd: { width: 1920, height: 1080 }
+};
+async function browserResize(cdp, params) {
+  let width;
+  let height;
+  if (params.preset?.toLowerCase() === "reset") {
+    await cdp.send("Emulation.clearDeviceMetricsOverride");
+    return { success: true, width: 0, height: 0 };
+  }
+  if (params.preset) {
+    const preset = PRESETS[params.preset.toLowerCase()];
+    if (!preset) {
+      throw new Error(
+        `Unknown preset "${params.preset}". Available: ${Object.keys(PRESETS).join(", ")}, reset`
+      );
+    }
+    width = preset.width;
+    height = preset.height;
+  } else {
+    width = params.width ?? 1280;
+    height = params.height ?? 720;
+  }
+  if (params.width !== void 0) width = params.width;
+  if (params.height !== void 0) height = params.height;
+  const deviceScaleFactor = params.deviceScaleFactor ?? 0;
+  const mobile = width < 768;
+  await cdp.send("Emulation.setDeviceMetricsOverride", {
+    width,
+    height,
+    deviceScaleFactor,
+    mobile
+  });
+  return {
+    success: true,
+    width,
+    height
+  };
+}
+
+// src/cli/commands/nav.ts
+var navigate = {
+  name: "navigate",
+  aliases: ["open", "goto"],
+  description: "Navigate the browser to a URL",
+  usage: "browsirai open <url> [--waitUntil=load]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const url = flags._0 ?? flags.url;
+    if (!url) {
+      console.error("Usage: browsirai open <url> [--waitUntil=load]");
+      console.error("  Provide a URL as the first argument or via --url=...");
+      process.exit(1);
+    }
+    const fullUrl = /^https?:\/\//i.test(url) ? url : `https://${url}`;
+    try {
+      const result = await browserNavigate(cdp, {
+        url: fullUrl,
+        waitUntil: flags.waitUntil,
+        timeout: flags.timeout ? Number(flags.timeout) : void 0
+      });
+      console.log(`Navigated to ${result.url}`);
+      if (result.title) {
+        console.log(`  Title: ${result.title}`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Navigate failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var back = {
+  name: "back",
+  description: "Navigate back or forward in browser history",
+  usage: "browsirai back [--direction=back]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const direction = flags._0 ?? flags.direction ?? "back";
+    try {
+      const result = await browserNavigateBack(cdp, { direction });
+      if (result.success) {
+        console.log(`Navigated ${direction}`);
+        if (result.url) {
+          console.log(`  URL: ${result.url}`);
+        }
+      } else {
+        console.log(`Cannot navigate ${direction} \u2014 no history entry`);
+        if (result.url) {
+          console.log(`  Current URL: ${result.url}`);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Navigate ${direction} failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var scroll = {
+  name: "scroll",
+  description: "Scroll the page in a direction",
+  usage: "browsirai scroll <direction> [--pixels=300] [--selector=...]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const direction = flags._0 ?? flags.direction ?? "down";
+    const amount = flags.pixels ? Number(flags.pixels) : flags.amount ? Number(flags.amount) : 300;
+    const selector = flags.selector;
+    try {
+      await browserScroll(cdp, {
+        direction,
+        amount,
+        selector
+      });
+      console.log(`Scrolled ${direction} ${amount}px`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Scroll failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var wait = {
+  name: "wait",
+  description: "Wait for a condition on the page",
+  usage: "browsirai wait [--text=...] [--selector=...] [--url=...] [--fn=...] [--time=N] [--timeout=30]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const timeout = flags.timeout ? Number(flags.timeout) : void 0;
+    const params = {};
+    if (flags.text !== void 0) params.text = flags.text;
+    if (flags.selector !== void 0) params.selector = flags.selector;
+    if (flags.url !== void 0) params.url = flags.url;
+    if (flags.fn !== void 0) params.fn = flags.fn;
+    if (flags.time !== void 0) params.time = Number(flags.time);
+    if (flags.visible !== void 0) params.visible = flags.visible === "true";
+    if (flags.state !== void 0) params.state = flags.state;
+    if (flags.networkIdle !== void 0) params.networkIdle = flags.networkIdle === "true";
+    if (flags.load !== void 0) params.load = flags.load === "true";
+    if (timeout !== void 0) params.timeout = timeout;
+    const hasCondition = Object.keys(params).some((k) => k !== "timeout");
+    if (!hasCondition && flags._0) {
+      params.text = flags._0;
+    }
+    if (!hasCondition && !flags._0) {
+      console.error("Usage: browsirai wait [--text=...] [--selector=...] [--url=...] [--fn=...] [--time=N]");
+      console.error("  Provide at least one condition to wait for.");
+      process.exit(1);
+    }
+    try {
+      const result = await browserWaitFor(cdp, params);
+      console.log(`Condition met (${result.elapsed}ms)`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Wait failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var tabs = {
+  name: "tab",
+  aliases: ["tabs"],
+  description: "List open browser tabs",
+  usage: "browsirai tab [--filter=*github*]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const filter = flags._0 ?? flags.filter;
+    try {
+      const result = await browserTabs(cdp, { filter });
+      if (result.tabs.length === 0) {
+        console.log("No tabs found");
+        return;
+      }
+      const lines = result.tabs.map(
+        (t) => `[${t.id}] ${t.title}
+  ${t.url}`
+      );
+      printResult(lines.join("\n\n"));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Tabs failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var close = {
+  name: "close",
+  description: "Close browser tab(s)",
+  usage: "browsirai close [--force] [--targetId=...] [--closeAll]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    try {
+      const result = await browserClose(cdp, {
+        force: flags.force === "true",
+        targetId: flags.targetId,
+        closeAll: flags.closeAll === "true"
+      });
+      if (result.success) {
+        console.log(`Closed ${result.closedTargets} tab(s)`);
+      } else {
+        console.log("Close failed \u2014 no targets matched");
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Close failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var resize = {
+  name: "resize",
+  description: "Resize the browser viewport",
+  usage: "browsirai resize <width> <height> [--preset=mobile]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const preset = flags.preset;
+    const width = flags._0 ? Number(flags._0) : flags.width ? Number(flags.width) : void 0;
+    const height = flags._1 ? Number(flags._1) : flags.height ? Number(flags.height) : void 0;
+    const deviceScaleFactor = flags.deviceScaleFactor ? Number(flags.deviceScaleFactor) : void 0;
+    if (!preset && width === void 0) {
+      console.error("Usage: browsirai resize <width> <height> [--preset=mobile]");
+      console.error("  Provide dimensions or a preset (mobile, tablet, desktop, fullhd, reset).");
+      process.exit(1);
+    }
+    try {
+      const result = await browserResize(cdp, {
+        width,
+        height,
+        preset,
+        deviceScaleFactor
+      });
+      if (preset?.toLowerCase() === "reset") {
+        console.log("Viewport reset to browser defaults");
+      } else {
+        console.log(`Viewport resized to ${result.width}x${result.height}`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Resize failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var navCommands = [
+  navigate,
+  back,
+  scroll,
+  wait,
+  tabs,
+  close,
+  resize
+];
+export {
+  navCommands
+};
+//# sourceMappingURL=nav.js.map