Glide

https://glide-browser.app/
Admin
Glide is an extensible and keyboard-focused web browser that enables navigation using just a...
Tokens:35,324
Snippets:365
Trust Score:6.6
Update:9 months ago
Show doc for...
Tokens:
Raw
### Install Addon from URL (JavaScript)

Source: https://glide-browser.app/api

Installs an addon from a given XPI URL, provided it hasn't already been installed. Use { force: true } to ensure reinstallation. The URL can typically be obtained by copying the link from an addon's download page.

```javascript
glide.addons.install(xpi_url, opts?);
```

--------------------------------

### Install and Bootstrap Glide Dependencies

Source: https://glide-browser.app/contributing

These commands install project dependencies, bootstrap the local repository by downloading Firefox source code and bundling Glide's assets, and configure the build environment. Requires Node.js v24 and pnpm.

```bash
pnpm install
pnpm bootstrap
pnpm bootstrap:mach
```

--------------------------------

### Open Local Glide Documentation

Source: https://glide-browser.app/contributing

Example of a file URI to open the locally rendered Glide documentation, assuming the build process has been run.

```plaintext
file:///path-to-glide-directory/src/glide/docs/dist/contributing.html
```

--------------------------------

### Addon Management

Source: https://glide-browser.app/api

Install new addons and list currently installed addons. Addons extend Glide's functionality with custom features and integrations.

```javascript
// Install an addon
glide.addons.install("https://example.com/my-addon.zip");

// List installed addons
glide.addons.list().then(addons => console.log(addons));
```

--------------------------------

### Create WindowLoaded Autocmd

Source: https://glide-browser.app/autocmds

Creates a Glide autocmd that fires only once when Glide is initially started. The callback function will be executed upon the first load of the Glide window. This is suitable for setup tasks that should only occur at the beginning of a session.

```javascript
glide.autocmds.create("WindowLoaded", () => {
  //
});
```

--------------------------------

### List Installed Addons (JavaScript)

Source: https://glide-browser.app/api

Retrieves a list of all installed addons. The list can be filtered by addon type, such as 'extension'.

```javascript
await glide.addons.list("extension");
```

--------------------------------

### Run Auto-Formatting with dprint

Source: https://glide-browser.app/contributing

This command applies automatic code formatting to the project using dprint. It is recommended to install and configure dprint separately if you haven't used it before.

```bash
pnpm fmt
```

--------------------------------

### Excmd Usage for Hint Filtering and Activation

Source: https://glide-browser.app/hints

Provides examples of using the ':hint' Excmd to filter hintable elements by CSS selector, editability, and to specify activation actions and hint generation locations.

```vim
:hint
:hint --action=newtab-click
:hint --location=browser-ui
:hint -s "a, input"
:hint -s "[onclick]"
:hint -e
:hint --include ".custom-button"

```

--------------------------------

### Glide Hints Show: Execute Click Action on Hint Element

Source: https://glide-browser.app/changelog

Illustrates the change in how actions are performed on hinted elements. The 'before' example directly calls `element.click()`, while the 'after' example uses `content.execute` for performing actions within the content process, reflecting a shift to main-process execution for callbacks.

```javascript
// before
glide.hints.show({
  action: (element) => {
    element.click();
  },
});

// after
glide.hints.show({
  action: async ({ content }) => {
    await content.execute((element) => element.click());
  },
});
```

--------------------------------

### Install Addons from URL

Source: https://glide-browser.app/changelog

This function installs browser addons directly from a provided XPI file URL. It can optionally force re-installation if the addon is already present. The URL can be obtained by copying the link from the 'Add to Firefox' button on addons.mozilla.org.

```javascript
glide.addons.install(
  "https://addons.mozilla.org/firefox/downloads/file/4598854/ublock_origin-1.67.0.xpi",
);
```

```javascript
glide.addons.install('...', { force: true });
```

--------------------------------

### Create General Autocmd with Pattern and Callback

Source: https://glide-browser.app/autocmds

Demonstrates the general syntax for creating a Glide autocmd. It takes an event name, a pattern (RegExp or object), and a callback function. The example shows how to create an autocmd that executes a callback only once by removing itself after invocation.

```javascript
glide.autocmds.create("UrlEnter", /url/, function autocmd() {
    // ... do things
    glide.autocmds.remove("UrlEnter", autocmd);
  });
```

--------------------------------

### Glide Options Get

Source: https://glide-browser.app/api

Retrieves a Glide option, prioritizing buffer-specific settings over global ones.

```APIDOC
## • glide.options
### ```
glide.options.get(name): glide.Options[Name]
```

Returns either a buffer-specific option, or the global version. In that order
```

--------------------------------

### DOM Helper: Create Element with Properties

Source: https://glide-browser.app/api

Example of using DOM.create_element to create an image element with specific properties like 'src'. This demonstrates setting direct element properties during creation.

```typescript
DOM.create_element("img", { src: "..." });
```

--------------------------------

### Glide Hints Show: Prioritize Largest Hint Width

Source: https://glide-browser.app/changelog

Demonstrates how to modify the behavior of `glide.hints.show` to select the hint with the largest width. The 'before' example shows a content-process execution, while the 'after' example illustrates the updated main-process execution with `content.map` for element properties.

```javascript
// before
glide.hints.show({
  pick: (hints) => {
    let biggest_hint = hints[0]!;
    let biggest_width = hints[0]!.element.offsetWidth;
    for (let i = 1; i < hints.length; i++) {
      const hint = hints[i]!;
      const width = hint.element.offsetWidth;
      if (width > biggest_width) {
        biggest_hint = hint;
        biggest_width = width;
      }
    }
    return [biggest_hint];
  },
});

// after
glide.hints.show({
  pick: async ({ hints, content }) => {
    const widths = await content.map((element) =>
      element.offsetWidth
    );
    let biggest_hint = hints[0]!;
    let biggest_width = widths[0]!;
    for (let i = 1; i < hints.length; i++) {
      const hint = hints[i]!;
      const width = widths[i]!;
      if (width > biggest_width) {
        biggest_hint = hint;
        biggest_width = width;
      }
    }
    return [biggest_hint];
  },
});
```

--------------------------------

### Configure Test Files in browser.toml

Source: https://glide-browser.app/contributing

Example configuration for including test files in the browser.toml file. Note that .js files from the dist directory should be used instead of .ts files.

```toml
[DEFAULT]
support-files = []

["dist/browser_my_test.js"]
```

--------------------------------

### Bookmarks Picker with JavaScript

Source: https://glide-browser.app/commandline

An example of creating a custom bookmarks picker using Glide's commandline. It displays the 10 most recent bookmarks and allows users to either create a new tab with the selected bookmark's URL or switch to an existing tab if the URL is already open. This utilizes Glide's keymap and commandline functionalities.

```javascript
glide.keymaps.set("normal", "<leader>o", async () => {
  const bookmarks = await browser.bookmarks.getRecent(10);

  glide.commandline.show({
    title: "bookmarks",
    options: bookmarks.map((bookmark) => ({
      label: bookmark.title,
      async execute() {
        const tab = await glide.tabs.get_first({
          url: bookmark.url,
        });
        if (tab) {
          await browser.tabs.update(tab.id, {
            active: true,
          });
        } else {
          await browser.tabs.create({
            active: true,
            url: bookmark.url,
          });
        }
      },
    })),
  });
}, { description: "Open the bookmarks picker" });
```

--------------------------------

### Set Keymap with Function Execution in Glide

Source: https://glide-browser.app/keys

Demonstrates how to set a key mapping that directly executes a JavaScript function instead of an excmd. This provides more flexibility for custom actions. The example shows a key binding that triggers `glide.hints.show()`.

```javascript
glide.keymaps.set("normal", "<leader>r", () => {
  glide.hints.show();
});
```

--------------------------------

### Clone Glide Repository

Source: https://glide-browser.app/contributing

This command clones the Glide browser source code from its GitHub repository. Ensure you have Git installed.

```bash
git clone https://github.com/glide-browser/glide
```

--------------------------------

### Set Hint Label Size in Glide Config

Source: https://glide-browser.app/tutor

A configuration snippet for Glide that sets the size of the hint labels displayed when hint mode is activated. This example increases the hint label size to '30px'.

```typescript
glide.o.hint_size = "30px";
```

--------------------------------

### Glide Custom Hint Label Generator

Source: https://glide-browser.app/changelog

Demonstrates how to implement a custom label generator for hints using `glide.hints.show`. This example provides a basic strategy to use the first two characters of an element's text content as the hint label. The `content` argument provides access to the DOM elements for processing.

```javascript
glide.hints.show({
  label_generator: async ({ content }) => {
    const texts = await content.map((element) =>
      element.textContent!
    );
    return texts.map((text) => text.slice(0, 2));
  },
});
```

--------------------------------

### Run Glide File Watcher

Source: https://glide-browser.app/contributing

This command starts a file watcher that automatically recompiles TypeScript files, rebuilds documentation, and copies source files to the Firefox engine directory during development. It is recommended to keep this running continuously.

```bash
pnpm dev
```

--------------------------------

### Create Split View - glide.unstable.split_views.create

Source: https://glide-browser.app/api

Starts a split view with the specified tabs. Requires at least two tabs. This function will not work if any of the provided tabs are pinned. Note that split views are experimental in Firefox and may contain bugs.

```typescript
glide.unstable.split_views.create(tabs, opts?): glide.SplitView
```

--------------------------------

### Navigate Tutorial

Source: https://glide-browser.app/tutor

Commands to navigate the Glide browser tutorial. ':tutor' reopens the tutorial, and 'Escape' returns to normal mode from any other mode.

```bash
:tutor
```

```bash
Escape
```

--------------------------------

### Include Configuration Files

Source: https://glide-browser.app/cookbook

Demonstrates how to split Glide configuration into multiple files using `glide.unstable.include`. This promotes modularity and organization in larger configurations.

```typescript
// glide.ts
glide.unstable.include("opts.glide.ts");

// opts.glide.ts
glide.g.mapleader = "~";
glide.o.which_key_delay = 500;
```

--------------------------------

### Keymap for Switching to a Tab

Source: https://glide-browser.app/cookbook

Creates a keybinding 'gt' in normal mode that finds the first tab matching 'example.com' and makes it active. This provides quick navigation to specific tabs.

```javascript
glide.keymaps.set("normal", "gt", async () => {
  const tab = await glide.tabs.get_first({
    url: "example.com",
  });
  assert(tab && tab.id);
  await browser.tabs.update(tab.id, { active: true });
}, { description: "[g]o to example.com" });
```

--------------------------------

### Initialize Glide Configuration

Source: https://glide-browser.app/tutor

Initializes the TypeScript configuration file for Glide, creating necessary boilerplate for the TypeScript Language Server to function correctly. This command sets up the default configuration file at ~/.config/glide/glide.ts.

```bash
:config_init home
```

--------------------------------

### Set Up Pre-Push Hook

Source: https://glide-browser.app/contributing

This command sets up a pre-push hook for Git, which automatically runs linting checks before each commit to ensure code quality. This requires the scripts directory to be present.

```bash
ln -s ../../scripts/pre-push.sh .git/hooks/pre-push
```

--------------------------------

### Environment Variables

Source: https://glide-browser.app/api

Provides functions to get, set, and delete environment variables within the Glide environment.

```APIDOC
## • glide.env
### ```
glide.env.get(name): string | null
```

Get the value of an environment variable.
If it does not exist null is returned.
### ```
glide.env.set(name, value): void
```

Set the value of an environment variable.
### ```
glide.env.delete(name): string | null
```

Remove an environment variable.
Does _not_ error if the environment variable did not already exist.
Returns the value of the deleted environment variable, if it did not exist null is returned.
```

--------------------------------

### Launch Glide Browser

Source: https://glide-browser.app/contributing

This command launches the built Glide browser. Additional arguments can be passed for configuration and debugging; refer to 'pnpm launch --help' for a full list.

```bash
pnpm launch
```

--------------------------------

### Preference Management

Source: https://glide-browser.app/api

Set, get, and clear user preferences. Preferences are persistent settings that can be stored for individual users.

```javascript
// Set a preference
glide.prefs.set("homepage", "https://example.com");

// Get a preference
const homepage = glide.prefs.get("homepage");
console.log(homepage);

// Clear a preference
glide.prefs.clear("homepage");
```

--------------------------------

### Configure oxlint LSP in Neovim

Source: https://glide-browser.app/contributing

This Lua configuration snippet enables the oxlint language server protocol (LSP) in Neovim. It specifies the command to run the LSP server and how to determine the root directory of the project.

```lua
vim.lsp.config('oxc', {
  cmd = {"npx", "oxc_language_server"},
  root_dir = function(buf, on_dir)
    local dir = vim.fs.root(0, { 'package.json', 'tsconfig.json' })
    if dir then on_dir(dir) end
  end,
})

```

--------------------------------

### Configuration Options

Source: https://glide-browser.app/api

This section details various configuration options available in Glide, including settings for jumplists, hint labels, focus behavior, scrolling, and native tab management.

```APIDOC
## glide.o.jumplist_max_entries: number

The maximum number of entries to include in the jumplist, i.e. how far back in history will the jumplist store.
@default 100

## glide.o.hint_size: string

The font size of the hint label, directly corresponds to the font-size property.
@default "11px"

## glide.o.hint_chars: string

The characters to include in hint labels.
@default "hjklasdfgyuiopqwertnmzxcvb"

## glide.o.hint_label_generator: glide.HintLabelGenerator

A function to produce labels for the given hints. You can provide your own function or use an included one:
  * glide.hints.label_generators.prefix_free; this is the default.
  * glide.hints.label_generators.numeric

For example:
```javascript
glide.o.hint_label_generator = ({ hints }) =>
  Array.from({ length: hints.length }, (_, i) => String(i));
```

Or using data from the hinted elements through content.execute():
```javascript
glide.hints.show({
  async label_generator({ content }) {
    const texts = await content.execute((element) =>
      element.textContent
    );
    return texts.map((text) =>
      text.trim().toLowerCase().slice(0, 2)
    );
  },
});
```

note: the above example is a very naive implementation and will result in issues if there are multiple elements that start with the same text.

## glide.o.switch_mode_on_focus: boolean

Determines if the current mode will change when certain element types are focused.
For example, if true then Glide will automatically switch to insert mode when an editable element is focused.
This can be useful for staying in the same mode while switching tabs.
@default true

## glide.o.scroll_implementation

Configure the strategy for implementing scrolling, this affects the h, j, k, l,<C-u>, <C-d>, G, and gg mappings.
This is exposed as the current keys implementation can result in non-ideal behaviour if a website overrides arrow key events.
This will be removed in the future when the kinks with the keys implementation are ironed out.
@default "keys"

## glide.o.native_tabs

Configure the behavior of the native tab bar.
  * show
  * hide
  * autohide (animated) shows the bar when the cursor is hovering over its default position

This works for both horizontal and vertical tabs.
For **vertical** tabs, the default collapsed width can be adjusted like this:
```javascript
glide.o.native_tabs = "autohide";
// fully collapse vertical tabs
glide.styles.add(css`
  :root {
    --uc-tab-collapsed-width: 2px;
  }
`);
```

See firefox-csshacks for more information.
**warning** : autohide does not work on MacOS at the moment.
@default "show"
```

--------------------------------

### Get Browser Preference Value

Source: https://glide-browser.app/api

Retrieves the value of a specified browser preference. If the preference is not defined, the function returns `undefined`.

```typescript
glide.prefs.get(name);
```

--------------------------------

### Basic Hint Mode Activation and Actions

Source: https://glide-browser.app/hints

Illustrates basic usage of Glide's hint mode, including activating elements with the default 'click' action and the 'newtab-click' action for opening links in a new tab.

```javascript
glide.hints.show({ action: "newtab-click" });

```

--------------------------------

### Command Line Show Options (TypeScript)

Source: https://glide-browser.app/api

Defines options for showing the command line interface, including default input, a title, and custom options. The custom options allow for defining labels, descriptions, rendering, matching, and execution callbacks. This is a TypeScript interface.

```typescript
/**
 * Fill the commandline with this input by default.
 */
input?: string;
/**
 * Configure the text shown at the top of the commandline.
 *
 * This is *only* used when `options` are provided.
 *
 * If `options` are given and this is not, then it defaults to `"options"`.
 */
title?: string;
/**
 * Replace the default commandline options.
 *
 * For example:
 *
 * ```typescript
 * ["option 1", "option 2", "option 3"].map((label) => ({
 *   label,
 *   execute() {
 *     console.log(`label ${label} was selected`);
 *   },
 * })),
 * ```
 */
options?: glide.CommandLineCustomOption[];
```

--------------------------------

### Filter Glide Tests with .only() and .skip()

Source: https://glide-browser.app/contributing

Examples of how to filter test functions within a single file using .only() and .skip() methods.

```javascript
add_task(...).skip();
add_task(...).only();
```

--------------------------------

### Style Manipulation

Source: https://glide-browser.app/api

Add, remove, check for, or get custom styles. This allows for dynamic modification of the browser's visual appearance.

```javascript
// Add a style
glide.styles.add("my-custom-style", ".my-element { color: blue; }");

// Check if a style exists
const hasStyle = glide.styles.has("my-custom-style");
console.log(hasStyle);

// Get a style
const styleContent = glide.styles.get("my-custom-style");
console.log(styleContent);

// Remove a style
glide.styles.remove("my-custom-style");
```

--------------------------------

### Build Glide Browser

Source: https://glide-browser.app/contributing

This command compiles the Glide browser project. The build process can take a significant amount of time, approximately 30 minutes on a high-end machine.

```bash
pnpm build
```

--------------------------------

### Tab Management

Source: https://glide-browser.app/api

Interact with browser tabs, including getting the active tab, the first tab, and querying tabs based on specific criteria.

```javascript
// Get the active tab
const activeTab = glide.tabs.active();
console.log(activeTab);

// Get the first tab
const firstTab = glide.tabs.get_first();
console.log(firstTab);

// Query tabs by URL
glide.tabs.query({ url: "https://*.google.com/*" }).then(tabs => {
  console.log(tabs);
});
```

--------------------------------

### Edit Glide Configuration

Source: https://glide-browser.app/tutor

Opens the Glide browser's configuration file in the default editor for modification. This allows users to customize browser behavior, such as hint label sizes.

```bash
:config_edit
```

--------------------------------

### Performing Custom Actions with Hints

Source: https://glide-browser.app/hints

Shows how to define and execute custom actions on hint-selected elements, such as copying element text content to the clipboard. This involves using an asynchronous action function.

```javascript
glide.hints.show({
  async action({ content }) {
    const text = await content.execute((target) => target.textContent ?? "");
    await navigator.clipboard.writeText(text);
  },
});

```

--------------------------------

### Environment Variable Management

Source: https://glide-browser.app/api

Get, set, and delete environment variables within Glide. These variables can be used to store and retrieve configuration or state information.

```javascript
// Get an environment variable
const userAgent = glide.env.get("user_agent");
console.log(userAgent);

// Set an environment variable
glide.env.set("theme", "dark");

// Delete an environment variable
glide.env.delete("theme");
```

--------------------------------

### Set Custom Homepage

Source: https://glide-browser.app/cookbook

Sets the browser's startup homepage to a custom URL ('https://example.com'). This allows users to define their preferred landing page upon browser launch.

```javascript
glide.prefs.set(
  "browser.startup.homepage",
  "https://example.com",
);
```

--------------------------------

### Get Environment Variable Value

Source: https://glide-browser.app/api

Retrieves the value of an environment variable by its name. If the environment variable does not exist, it returns null. This function is part of the glide.env API.

```javascript
glide.env.get(name): string | null
```

--------------------------------

### Send Message from Main Process to Child Actor

Source: https://glide-browser.app/contributing

Example of how the main process in Glide sends a message to a child actor using send_async_message. Messages are defined in GlideHandlerParent.sys.mts::ParentMessages.

```javascript
GlideBrowser.get_focused_actor().send_async_message(
  "Glide::ReplaceChar",
  {
    character: "a",
  },
);
```

--------------------------------

### Get Split View - glide.unstable.split_views.get

Source: https://glide-browser.app/api

Retrieves the corresponding split view given a tab, tab ID, or split view ID. Returns null if no split view is found.

```typescript
glide.unstable.split_views.get(tab): glide.SplitView | null
```

--------------------------------

### Glide Tabs API

Source: https://glide-browser.app/api

Interact with browser tabs, including getting the active tab, finding the first tab matching a query, and querying all tabs based on specified properties.

```APIDOC
## glide.tabs.active()

### Description
Returns the active tab for the currently focused window.

### Method
`glide.tabs.active(): Promise<glide.TabWithID>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
async function getActiveTab() {
  const tab = await glide.tabs.active();
  console.log('Active tab:', tab);
}
getActiveTab();
```

### Response
#### Success Response (200)
- **return value** (glide.TabWithID) - An object representing the active tab with its ID.

#### Response Example
```json
{
  "id": 1,
  "title": "New Tab",
  "url": "about:newtab",
  "active": true,
  "windowId": 1
}
```
```

```APIDOC
## glide.tabs.get_first()

### Description
Finds the first tab matching the given query filter.

### Method
`glide.tabs.get_first(query): Promise<Browser.Tabs.Tab | undefined>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **query** (object) - An object with properties to filter tabs (e.g., `{ url: 'https://*' }`).

### Request Example
```javascript
async function findFirstExampleTab() {
  const tab = await glide.tabs.get_first({ url: 'https://example.com/*' });
  if (tab) {
    console.log('Found tab:', tab);
  } else {
    console.log('No matching tab found.');
  }
}
findFirstExampleTab();
```

### Response
#### Success Response (200)
- **return value** (Browser.Tabs.Tab | undefined) - The first matching tab object, or `undefined` if no match is found.

#### Response Example
```json
{
  "id": 5,
  "url": "https://example.com/page",
  "title": "Example Page",
  "active": false,
  "windowId": 1
}
```
```

```APIDOC
## glide.tabs.query()

### Description
Gets all tabs that have the specified properties, or all tabs if no properties are specified.

### Method
`glide.tabs.query(query): Promise<Browser.Tabs.Tab[]>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **query** (object) - An object with properties to filter tabs (e.g., `{ pinned: true }`). If empty, all tabs are returned.

### Request Example
```javascript
async function getAllPinnedTabs() {
  const pinnedTabs = await glide.tabs.query({ pinned: true });
  console.log('Pinned tabs:', pinnedTabs);
}
getAllPinnedTabs();
```

### Response
#### Success Response (200)
- **return value** (Browser.Tabs.Tab[]) - An array of tab objects matching the query.

#### Response Example
```json
[
  {
    "id": 2,
    "url": "https://example.com",
    "title": "Example Site",
    "pinned": true,
    "active": false,
    "windowId": 1
  }
]
```
```

--------------------------------

### Build Glide Docs in Watch Mode

Source: https://glide-browser.app/contributing

Command to run only the Markdown to HTML build step in watch mode, useful for iterating on documentation without a full Glide build.

```bash
pnpm dev:docs
```

--------------------------------

### Glide Preferences API

Source: https://glide-browser.app/api

Manage browser preferences using `glide.prefs`. This API provides a way to set, get, and clear user preferences, acting as an alternative to `prefs.js` or `about:config`.

```APIDOC
## glide.prefs.set()

### Description
Sets a preference value. It's recommended to call this at the top level of your configuration.

### Method
`glide.prefs.set(name, value): void`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **name** (string) - The name of the preference to set.
- **value** (string | number | boolean) - The value to set for the preference.

### Request Example
```javascript
glide.prefs.set('browser.tabs.closeWindowWithLastTab', true);
```

### Response
#### Success Response (200)
Void

#### Response Example
N/A
```

```APIDOC
## glide.prefs.get()

### Description
Gets the value of a preference.

### Method
`glide.prefs.get(name): string | number | boolean | undefined`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **name** (string) - The name of the preference to get.

### Request Example
```javascript
const closeWindowPref = glide.prefs.get('browser.tabs.closeWindowWithLastTab');
console.log(closeWindowPref);
```

### Response
#### Success Response (200)
- **return value** (string | number | boolean | undefined) - The value of the preference, or `undefined` if it's not defined.

#### Response Example
```json
true
```
```

```APIDOC
## glide.prefs.clear()

### Description
Resets a preference value back to its default.

### Method
`glide.prefs.clear(name): void`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **name** (string) - The name of the preference to clear.

### Request Example
```javascript
glide.prefs.clear('browser.tabs.closeWindowWithLastTab');
```

### Response
#### Success Response (200)
Void

#### Response Example
N/A
```

--------------------------------

### Ignore Keymappings for Specific Website

Source: https://glide-browser.app/cookbook

Disables all keymappings when a URL on 'example.com' is entered and restores them upon leaving. This prevents unintended keymap activations on a particular site.

```javascript
glide.autocmds.create("UrlEnter", {
  hostname: "example.com",
}, async () => {
  await glide.excmds.execute("mode_change ignore");
  return () => glide.excmds.execute("mode_change normal");
});
```

--------------------------------

### Get Active Tab Information

Source: https://glide-browser.app/api

Retrieves the active tab object for the currently focused window. This function provides enhanced error handling compared to directly using `browser.tabs.query`.

```typescript
const tab = await glide.tabs.active();
```

--------------------------------

### Configure Hint Label Generators (JavaScript)

Source: https://glide-browser.app/api

Allows configuration of how hints are labeled. 'prefix_free' generates unique combinations based on specified characters, while 'numeric' generates sequential numbers.

```javascript
glide.hints.label_generators.prefix_free: glide.HintLabelGenerator
```

```javascript
glide.hints.label_generators.numeric: glide.HintLabelGenerator
```

--------------------------------

### Custom Commandline Options with JavaScript

Source: https://glide-browser.app/commandline

Demonstrates how to provide custom options to Glide's commandline. The options replace defaults and can include labels, execution logic, and custom rendering functions. Input filters against option.label and option.description.

```javascript
glide.commandline.show({
  options: ["foo", "bar", "baz"].map((label) => ({
    label,
    execute() {
      console.log(`label ${label} was selected`);
    },
  })),
});
```

```javascript
{
  label: bookmark.title,
  render() {
    return DOM.create_element("div", {
      style: {
        display: "flex",
        alignItems: "center",
        gap: "8px",
      },
      children: [
        DOM.create_element("span", [bookmark.title]),
        DOM.create_element("span", [bookmark.url!], {
          style: { color: "#777", fontSize: "0.9em" },
        }),
      ],
    });
  },
};
```

--------------------------------

### Get File Information with glide.fs.stat

Source: https://glide-browser.app/api

Retrieves file metadata such as size and modification date. Relative paths are resolved against the config directory. If no config directory is set, relative paths are disallowed.

```javascript
const stat = await glide.fs.stat("userChrome.css");
stat.last_modified; // 1758835015092
stat.type; // "file"
```

--------------------------------

### Focus Page Element

Source: https://glide-browser.app/tutor

Returns focus to the main web page content from an input element or other focused elements. This is achieved by pressing Ctrl + Comma.

```bash
<C-,>
```

--------------------------------

### Navigate Command Line

Source: https://glide-browser.app/cookbook

Sets custom keybindings for navigating the command line history. '<c-j>' moves to the next command, and '<c-k>' moves to the previous command.

```javascript
glide.keymaps.set(
  "command",
  "<c-j>",
  "commandline_focus_next",
);
glide.keymaps.set(
  "command",
  "<c-k>",
  "commandline_focus_back",
);
```

--------------------------------

### Show Commandline UI in Glide

Source: https://glide-browser.app/api

Displays the commandline interface, which can be used to list all `excmds` or to present custom options defined by the developer. The `opts` parameter allows for customization of the title and the list of options with associated execution functions.

```typescript
await glide.commandline.show({
  title: "my options",
  options: ["option 1", "option 2", "option 3"].map((
    label,
  ) => ({
    label,
    execute() {
      console.log(`label ${label} was selected`);
    },
  })),
});
```

--------------------------------

### Create Text Macros

Source: https://glide-browser.app/cookbook

Sets a keybinding to execute a sequence of actions: switch to insert mode, type a string, and exit insert mode. This is useful for quickly inserting predefined text snippets.

```javascript
glide.keymaps.set("normal", "<leader>ts", async () => {
  await glide.keys.send("i"); // switch to insert mode
  await glide.keys.send("¯\\_(ツ)_/¯"); // "type" the keys
  await glide.keys.send("<esc>"); // exit insert mode
});
```

--------------------------------

### Key Notation Definition (TypeScript)

Source: https://glide-browser.app/api

Defines the structure for key notation, including the key string itself and boolean flags for modifiers (alt, ctrl, meta, shift). Examples are provided for common key notations. This is a TypeScript interface.

```typescript
/**
 * @example <leader>
 * @example h
 * @example j
 * @example K
 * @example L
 * @example <Tab>
 */
key: string;

// modifiers
alt: boolean;
ctrl: boolean;
meta: boolean;
shift: boolean;
```

--------------------------------

### Set Custom Hint Label Generator Function

Source: https://glide-browser.app/api

Configures a custom function to generate labels for hints. This example demonstrates generating sequential numeric labels based on the number of hints. It requires the 'hints' object as input.

```javascript
glide.o.hint_label_generator = ({ hints }) =>
  Array.from({ length: hints.length }, (_, i) => String(i));
```

--------------------------------

### Create UrlEnter Autocmd with Hostname Pattern

Source: https://glide-browser.app/autocmds

Creates a Glide autocmd for the 'UrlEnter' event, triggered when the focused URL changes on a specific hostname (e.g., 'example.com'). The callback function is executed upon matching the pattern. The callback can also return a function to be executed on subsequent 'UrlEnter' events.

```javascript
glide.autocmds.create("UrlEnter", {
  hostname: "example.com",
}, () => {
  //
});
```

--------------------------------

### Path and File System Operations

Source: https://glide-browser.app/api

Access important directory paths (current working directory, home, temp, profile) and perform file system operations like reading, writing, checking existence, and getting file stats.

```javascript
// Get directory paths
console.log(glide.path.cwd);
console.log(glide.path.home_dir);
console.log(glide.path.temp_dir);
console.log(glide.path.profile_dir);

// Join path segments
const fullPath = glide.path.join(glide.path.home_dir, "documents", "file.txt");
console.log(fullPath);

// Read a file
glide.fs.read(fullPath).then(content => console.log(content));

// Write to a file
glide.fs.write(fullPath, "Hello, Glide FS!");

// Check if a file exists
glide.fs.exists(fullPath).then(exists => console.log(exists));

// Get file stats
glide.fs.stat(fullPath).then(stats => console.log(stats));
```

--------------------------------

### Set Normal Mode Keymap for Example.com Tab

Source: https://glide-browser.app/config

This TypeScript snippet demonstrates how to set a keymap in Glide's normal mode. It maps the 'gt' key to a function that finds the first tab containing 'example.com', makes it active, and includes a descriptive label for the keymap. It uses the glide.keymaps.set, glide.tabs.get_first, and browser.tabs.update APIs.

```typescript
// ~/.config/glide/glide.ts
glide.keymaps.set("normal", "gt", async () => {
  const tab = await glide.tabs.get_first({
    url: "example.com",
  });
  assert(tab && tab.id);
  await browser.tabs.update(tab.id, { active: true });
}, { description: "[g]o to example.com" });
```

--------------------------------

### Set Keymap for Multiple Modes in Glide

Source: https://glide-browser.app/keys

Allows setting a key mapping that applies to multiple modes simultaneously. This is achieved by passing an array of mode strings as the first argument to the `glide.keymaps.set` function. The example shows binding a key to both 'normal' and 'visual' modes.

```javascript
glide.keymaps.set(["normal", "visual"], "<leader>r", "...");
```

--------------------------------

### Process Management API

Source: https://glide-browser.app/api

Utilities for spawning, managing, and interacting with child processes.

```APIDOC
## POST /process/spawn

### Description
Spawns a new child process.

### Method
POST

### Endpoint
`/process/spawn`

#### Request Body
- **command** (string) - The command to execute.
- **args** (array<string>) - Arguments to pass to the command.
- **options** (object) - Optional spawn options (e.g., `cwd`, `env`, `stderr`).
  - **cwd** (string) - Optional - The current working directory for the process.
  - **env** (object) - Optional - Environment variables for the process.
  - **extend_env** (boolean) - Optional - Whether to extend the current environment variables.
  - **success_codes** (array<integer>) - Optional - Array of exit codes considered successful.
  - **check_exit_code** (boolean) - Optional - If `false`, do not throw an error for non-zero exit codes. Defaults to `true`.
  - **stderr** (string) - Optional - Control where stderr output is sent (`'pipe'` or `'stdout'`). Defaults to `'pipe'`.

### Request Example
```json
{
  "command": "node",
  "args": ["script.js"],
  "options": {
    "cwd": "/path/to/dir",
    "stderr": "pipe"
  }
}
```

### Response
#### Success Response (200)
- **process** (object) - An object representing the spawned process.
  - **pid** (number) - The process ID.
  - **exit_code** (number | null) - The process exit code, or `null` if not exited.
  - **stdout** (ReadableStream<string>) - A stream of stdout output.
  - **stderr** (ReadableStream<string> | null) - A stream of stderr output, or `null` if piped to stdout.
  - **wait** (function) - Function to wait for the process to exit.
  - **kill** (function) - Function to kill the process.

### Response Example
```json
{
  "process": {
    "pid": 1234,
    "exit_code": null,
    "stdout": "<ReadableStream>",
    "stderr": "<ReadableStream>",
    "wait": "function",
    "kill": "function"
  }
}
```

## GET /process/:pid/status

### Description
Get the status of a running process.

### Method
GET

### Endpoint
`/process/:pid/status`

#### Path Parameters
- **pid** (integer) - Required - The process ID.

### Response
#### Success Response (200)
- **exit_code** (number | null) - The process exit code, or `null` if not exited.

### Response Example
```json
{
  "exit_code": 0
}
```
```

--------------------------------

### Generate Hint Labels Using Element Content

Source: https://glide-browser.app/api

Provides a label generator function that extracts and processes text content from hinted elements. It maps over the content, trims whitespace, converts to lowercase, and takes the first two characters. This function can lead to issues if multiple elements share the same starting text.

```javascript
glide.hints.show({
  async label_generator({ content }) {
    const texts = await content.execute((element) =>
      element.textContent
    );
    return texts.map((text) =>
      text.trim().toLowerCase().slice(0, 2)
    );
  },
});
```

--------------------------------

### Run All Glide Tests

Source: https://glide-browser.app/contributing

This command executes all tests defined within the Glide project. Tests are written using the mochitest framework.

```bash
pnpm test
```

--------------------------------

### Create UrlEnter Autocmd with Keymap for GitHub

Source: https://glide-browser.app/autocmds

Creates a Glide autocmd for the 'UrlEnter' event specifically for 'github.com' hostnames. When this event occurs on GitHub, it sets a normal mode keymap '<leader>gi' that triggers the `github_go_to_issues` function. This allows users to quickly navigate to the issues page from any GitHub repository page.

```javascript
glide.autocmds.create("UrlEnter", {
  hostname: "github.com",
}, async () => {
  glide.buf.keymaps.set(
    "normal",
    "<leader>gi",
    github_go_to_issues,
  );
});
```

--------------------------------

### Reload Glide Configuration

Source: https://glide-browser.app/tutor

Reloads the Glide browser's configuration file. This command is used after modifying the configuration file to apply the changes without restarting the browser.

```bash
:config_reload
```

--------------------------------

### Enter Insert Mode in Glide

Source: https://glide-browser.app/tutor

Manually enters insert mode in the Glide browser. This is useful when keyboard shortcuts in normal mode conflict with website-specific key bindings.

```bash
i
```

--------------------------------

### Spawn a New Process

Source: https://glide-browser.app/api

Spawns a new process with the specified command and arguments. It can optionally take an options object, including 'check_exit_code' to control error throwing on non-zero exit codes and 'cwd' for the current working directory. Note that on macOS, the PATH environment variable may need to be explicitly set.

```javascript
const proc = await glide.process.spawn("kitty", [
  "nvim",
  "glide.ts",
], { cwd: "~/.dotfiles/glide" });
console.log("opened kitty with pid", proc.pid);
```

--------------------------------

### Buffer Preference and Keymap Management

Source: https://glide-browser.app/api

Set specific preferences and keymaps for individual buffers (e.g., different tabs or pages). This allows for context-aware configurations.

```javascript
// Set a preference for the current buffer
glide.buf.prefs.set('auto_save', true);

// Set a keymap for the current buffer
glide.buf.keymaps.set('normal', 'a', 'open_url');

// Delete a keymap for the current buffer
glide.buf.keymaps.del('normal', 'a');
```

--------------------------------

### Create a New Excmd

Source: https://glide-browser.app/api

Defines and registers a new custom `excmd` within the Glide environment. This involves providing metadata such as the command's name and description, and a function to execute when the command is invoked. The created command can be registered globally.

```typescript
const cmd = glide.excmds.create({
  name: "my_excmd",
  description: "...",
}, () => {
  // ...
});
declare global {
  interface ExcmdRegistry {
    my_excmd: typeof cmd;
  }
}
```

--------------------------------

### Process Management

Source: https://glide-browser.app/api

Enables spawning and executing external processes, with options for error checking and working directories.

```APIDOC
## • glide.process
### ```
glide.process.spawn(command, args?, opts?): Promise<glide.Process>
```

Spawn a new process. The given command can either be the name of a binary in the PATH or an absolute path to a binary file.
If the process exits with a non-zero code, an error will be thrown, you can disable this check with { check_exit_code: false }.
```javascript
const proc = await glide.process.spawn("kitty", [
  "nvim",
  "glide.ts",
], { cwd: "~/.dotfiles/glide" });
console.log("opened kitty with pid", proc.pid);
```

**note** : on macOS, the PATH environment variable is likely not set to what you'd expect, as applications do not inherit your shell environment. you can update it with glide.env.set("PATH", "/usr/bin:/usr/.local/bin").
### ```
glide.process.execute(command, args?, opts?): Promise<glide.CompletedProcess>
```

Spawn a new process and wait for it to exit.
See  glide.process.spawn for more information.
```

--------------------------------

### Configuring Glide Options

Source: https://glide-browser.app/api

Set and manage browser-wide options for Glide. This includes configuring mapping timeouts, yank highlight colors and duration, and which-key delay. Custom options can be added by merging the `GlideOptions` interface.

```javascript
// Declare custom option
declare global {
  interface GlideOptions {
    my_custom_option?: boolean;
  }
}

// Set options
glide.o.mapping_timeout = 250;
glide.o.yank_highlight = "#ff6b35"; // Orange highlight
glide.o.yank_highlight_time = 200;
glide.o.which_key_delay = 400;
glide.o.my_custom_option = true;
```

--------------------------------

### Set Website-Specific Privacy Preference

Source: https://glide-browser.app/cookbook

Sets the 'resistFingerprinting' preference to true globally and then overrides it to false for 'example.com' when entering a URL. This allows for fine-grained privacy control.

```javascript
glide.prefs.set("privacy.resistFingerprinting", true);

glide.autocmds.create("UrlEnter", {
  hostname: "example.com",
}, () => {
  glide.buf.prefs.set(
    "privacy.resistFingerprinting",
    false,
  );
});
```

--------------------------------

### Create URL Enter Autocommands in Glide

Source: https://glide-browser.app/faq

This snippet demonstrates how to create an autocommand that automatically enters insert mode when a specific URL is entered. It uses the `glide.autocmds.create` function with a `UrlEnter` event and specifies the `hostname` to trigger the command. The `glide.excmds.execute` function is used to change the mode to 'insert'.

```typescript
glide.autocmds.create("UrlEnter", {
  hostname: "example.com",
}, async () => {
  await glide.excmds.execute("mode_change insert");
});
```

--------------------------------

### Custom Hint Label Generator Configuration

Source: https://glide-browser.app/hints

Demonstrates how to customize the hint label generation alphabet and provide a custom generator function. This allows for personalized hint label sequences.

```javascript
glide.o.hint_chars = "hjklasdfgyuiopqwertnmzxcvb";
glide.o.hint_label_generator = (chars) => {
  // Custom generator logic here
  return (index) => {
    // return label for index
  };
};

```

--------------------------------

### Keymap Options (TypeScript)

Source: https://glide-browser.app/api

Defines options for configuring keymaps, including an optional description, a buffer-specific flag, and a flag to retain key display after execution. This is a TypeScript interface.

```typescript
description?: string | undefined;
/**
 * If `true`, applies the mapping for the current buffer instead of globally.
 *
 * @default {false}
 */
buffer?: boolean;
/**
 * If true, the key sequence will be displayed even after the mapping is executed.
 *
 * This is useful for mappings that are conceptually chained but are not *actually*, e.g. `diw`.
 *
 * @default false
 */
retain_key_display?: boolean;
```

--------------------------------

### Styles

Source: https://glide-browser.app/api

Module for managing styles within the Glide application.

```APIDOC
## • glide.styles

```

--------------------------------

### Key Event Simulation

Source: https://glide-browser.app/api

Send key events, navigate through key sequences, and parse key notations. This is useful for automating user interactions or testing keybindings.

```javascript
// Send a key event
glide.keys.send('<c-t>');

// Send the next key in a sequence
glide.keys.next();

// Send the next key, passing through non-mapped keys
glide.keys.next_passthrough();

// Send the next key as a string
glide.keys.next_str('hello');

// Parse a key notation
const parsedKey = glide.keys.parse("<ctrl>+c");
console.log(parsedKey);
```

--------------------------------

### Hint Management

Source: https://glide-browser.app/api

Show hints on the page for interactive elements and manage hint label generators. Hints help users navigate and interact with web page elements using keyboard shortcuts.

```javascript
// Show hints for all links
glide.hints.show('a');

// Use a prefix-free label generator
glide.hints.label_generators.prefix_free;

// Use a numeric label generator
glide.hints.label_generators.numeric;
```
Tokens:
Raw