### Query Documentation Example

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/shared.md

This example shows how to query the documentation dynamically using an HTTP GET request with the `ask` query parameter. This is useful for retrieving specific information or clarifications not explicitly present on the page.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/apis/shared.md?ask=<question>
```

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

### Querying Documentation via HTTP GET

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/other/app-settings.md

This example shows how to query the documentation dynamically by appending the 'ask' query parameter to the page URL. Use this for questions not explicitly answered on the page.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/ui/other/app-settings.md?ask=<question>
```

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

### Register and Start a Cron Job

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/cron.md

This example demonstrates how to register a recurring job to refresh an anime cache every 15 minutes and then start the cron scheduler. Ensure the 'cron' permission is granted.

```typescript
$ui.register((ctx) => {
    ctx.cron.add("refresh-anime-cache", "*/15 * * * *", () => {
        console.log("refreshing anime cache")
    })

    ctx.cron.start()
})
```

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

### UI Plugin Auth Example

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/other/auth.md

This example demonstrates how to register a UI plugin that uses the ctx.auth API to log in and out of AniList. It includes input fields for tokens and toast notifications for feedback.

```typescript
$ui.register((ctx) => {
    const tray = ctx.newTray({
        tooltipText: "AniList auth",
        withContent: true,
    })

    const tokenRef = ctx.fieldRef("")

    ctx.registerEventHandler("login-anilist", async () => {
        try {
            await ctx.auth.login(tokenRef.current ?? "")
            tokenRef.setValue("")
            ctx.toast.success("AniList login updated")
        } catch (error) {
            ctx.toast.alert(`Login failed: ${error.message}`)
        }
    })

    ctx.registerEventHandler("logout-anilist", async () => {
        try {
            await ctx.auth.logout()
            ctx.toast.info("AniList logged out")
        } catch (error) {
            ctx.toast.alert(`Logout failed: ${error.message}`)
        }
    })

    tray.render(() => tray.stack([
        tray.input("AniList token", { fieldRef: tokenRef }),
        tray.button("Log in", { onClick: "login-anilist" }),
        tray.button("Log out", { onClick: "logout-anilist" }),
    ]))
})
```

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

### Query Documentation via HTTP GET

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/downloading/torrent-client.md

Perform an HTTP GET request to query the documentation dynamically. Include your question in the 'ask' query parameter.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/ui/downloading/torrent-client.md?ask=<question>
```

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

### Example: Fetching Data on Navigation

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/basics.md

This example demonstrates fetching data based on navigation events. It uses states to track the current media ID and fetched data, and an effect to trigger the fetch when the ID changes.

```typescript
const currentMediaId = ctx.state<number | null>(null)
const fetchedData = ctx.state([])

// When the user navigates to an anime, get the media ID
ctx.screen.onNavigate((e) => {
    if (e.pathname === "/entry" && !!e.searchParams.id) {
        const id = parseInt(e.searchParams.id);
        currentMediaId.set(id);
    } else {
        currentMediaId.set(null);
    }
});

// Trigger 'ctx.screen.onNavigate' when the plugin loads 
ctx.screen.loadCurrent()

// Fetch data each time the media ID changes.
ctx.effect(async () => {
    if (!currentMediaId.get()) return
    
    const res = ctx.fetch(`https://example.com/anilistId?=${currentMediaId.get()}`)
    // Store the results
    fetchedData.set(res.json())
}, [currentMediaId])
```

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

### Query Documentation via HTTP GET

Source: https://seanime.gitbook.io/seanime-extensions/plugins

Perform an HTTP GET request to query the documentation dynamically. Include your specific question in the 'ask' query parameter.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins.md?ask=<question>
```

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

### Example: Managing Library Auto Scan Settings

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/other/app-settings.md

This TypeScript example demonstrates how to use ctx.appSettings to read, update, and patch the 'library.autoScan' setting. It includes event handlers for refreshing and toggling the setting, and updates the UI accordingly.

```typescript
$ui.register((ctx) => {
    const tray = ctx.newTray({
        tooltipText: "Library settings",
        withContent: true,
    })

    const autoScanState = ctx.state<boolean | null>(null)

    async function loadAutoScan() {
        const enabled = await ctx.appSettings.get(
            "library.autoScan",
            false,
        )
        autoScanState.set(Boolean(enabled))
    }

    ctx.registerEventHandler("refresh-auto-scan", async () => {
        try {
            await loadAutoScan()
            ctx.toast.info("Loaded app settings")
        } catch (error) {
            ctx.toast.alert(`Could not read settings: ${error.message}`)
        }
    })

    ctx.registerEventHandler("toggle-auto-scan", async () => {
        try {
            const nextValue = !autoScanState.get()
            await ctx.appSettings.patch({
                library: {
                    autoScan: nextValue,
                },
            })
            autoScanState.set(nextValue)
            ctx.toast.success(`Auto Scan: ${nextValue ? "on" : "off"}`)
        } catch (error) {
            ctx.toast.alert(`Could not update settings: ${error.message}`)
        }
    })

    tray.render(() => tray.stack([
        tray.text(`Auto Scan: ${autoScanState.get() === null ? "unknown" : autoScanState.get() ? "enabled" : "disabled"}`),
        tray.button("Refresh", { onClick: "refresh-auto-scan" }),
        tray.button("Toggle", { onClick: "toggle-auto-scan" }),
    ]))

    loadAutoScan()
})
```

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

### Example Plugin: Storing Scan Durations

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/storage.md

A plugin example that stores scan completion times and manages a history of scan durations using $store and $storage.

```typescript
// A simple plugin that stores the history of scan durations
function init() {
    $app.onScanCompleted((e) => {
        // Store the scanning duration (in ms)
        $store.set("scan-completed", e.duration)
        
        e.next()
    })
    
    $ui.register((ctx) => {

        // Callback is triggered when the value is updated
        $store.watch<number>("scan-completed", (value) => {
            const date = new Date()
            const now = date.toISOString().replaceall(".", "_")
            
            // Add the value to the history
            $storage.set("scan-duration-history."+now, {
                duration: value,
                durationInSeconds: value/1000,
                addedAt: date,
            })
            
            ctx.toast.info(`Scanning took ${value/1000} seconds!`);
        })
        
        function deleteHistory() {
            $storage.remove("scan-duration-history")
        }
    })
}
```

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

### Start the Cron Scheduler

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/cron.md

Call the `start` method to begin executing registered cron jobs. Calling it again will restart the scheduler.

```javascript
ctx.cron.start()
```

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

### Plugin Example: Storing Scan Durations

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/store.md

An example plugin that stores scan completion durations and logs them to storage with toast notifications.

```typescript
// A simple plugin that stores the history of scan durations
function init() {
    $app.onScanCompleted((e) => {
        // Store the scanning duration (in ms)
        $store.set("scan-completed", e.duration)
        
        e.next()
    })
    
    $ui.register((ctx) => {

        // Callback is triggered when the value is updated
        $store.watch<number>("scan-completed", (value) => {
            const now = new Date().toISOString().replaceall(".", "_")
            $storage.set("scan-duration-history."+now, value)
            ctx.toast.info(`Scanning took ${value/1000} seconds!`)
        })
    })
}
```

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

### Ask a Question via HTTP GET

Source: https://seanime.gitbook.io/seanime-extensions/llms.txt

Perform an HTTP GET request to the documentation index with an 'ask' parameter to get a direct answer to a specific question, along with relevant excerpts and sources. This is the recommended method for finding information when the exact page is unknown.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/apis/system.md?ask=<question>
```

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

### Example: Managing Extension Enable/Disable State

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/other/extensions.md

This example shows how to register UI elements (a tray with an input and buttons) to enable or disable another extension using its ID. It handles user input for the extension ID and displays toast notifications for success or failure.

```typescript
$ui.register((ctx) => {
    const tray = ctx.newTray({
        tooltipText: "Extension manager",
        withContent: true,
    })

    const extensionIdRef = ctx.fieldRef("my-other-plugin")

    ctx.registerEventHandler("disable-extension", async () => {
        try {
            await ctx.extensions.disable(extensionIdRef.current ?? "")
            ctx.toast.warning("Extension disabled")
        } catch (error) {
            ctx.toast.alert(`Disable failed: ${error.message}`)
        }
    })

    ctx.registerEventHandler("enable-extension", async () => {
        try {
            await ctx.extensions.enable(extensionIdRef.current ?? "")
            ctx.toast.success("Extension enabled")
        } catch (error) {
            ctx.toast.alert(`Enable failed: ${error.message}`)
        }
    })

    tray.render(() => tray.stack([
        tray.input("Extension ID", { fieldRef: extensionIdRef }),
        tray.button("Disable", { onClick: "disable-extension" }),
        tray.button("Enable", { onClick: "enable-extension" }),
    ]))
})
```

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

### Query Documentation with GET Request

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/helpers.md

Perform an HTTP GET request to the current page URL, appending the `ask` query parameter with your natural language question. The response will contain a direct answer and relevant excerpts.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/ui/helpers.md?ask=<question>
```

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

### startManualTracking

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/playback-external.md

Starts manual progress tracking for media not launched through Seanime's integrated playback APIs.

```APIDOC
## startManualTracking

### Description
Starts manual progress tracking for media that is not being launched through Seanime's integrated playback APIs. If `clientId` is omitted, Seanime broadcasts it to all clients.

### Method
INVOKE

### Endpoint
ctx.playback.startManualTracking(opts: PlaybackManualTrackingOptions)

### Parameters
#### Request Body
- **opts** (PlaybackManualTrackingOptions) - Required - Options for manual tracking.
  - **mediaId** (Number) - Required - AniList media ID to track.
  - **episodeNumber** (Number) - Required - Episode number to sync.
  - **clientId** (String) - Optional - Client ID override.

### Response
#### Success Response
Manual tracking is started successfully.

### Response Example
```typescript
await ctx.playback.startManualTracking({
  mediaId: 21,
  episodeNumber: 1,
})
```
```

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

### Query Documentation Dynamically

Source: https://seanime.gitbook.io/seanime-extensions/frequently-asked/feature-requests.md

To get information not directly on a page, send an HTTP GET request to the page URL with an 'ask' query parameter. The question should be specific and in natural language.

```http
GET https://seanime.gitbook.io/seanime-extensions/frequently-asked/feature-requests.md?ask=<question>
```

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

### Quick Debugging Example

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/debug.md

Logs scan completion details and UI thread startup. These methods are only active for development plugins.

```typescript
$app.onScanCompleted((event) => {
    $debug.info("scan completed", {
        duration: event.duration,
        mediaCount: event.stats?.animeCount,
    })

    event.next()
})

$ui.register((ctx) => {
    $debug.mark("ui thread started")
})
```

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

### Start Manual Tracking

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/playback-external.md

Starts manual progress tracking for media not launched through Seanime's integrated APIs. Specify media ID and episode number.

```typescript
await ctx.playback.startManualTracking({
  mediaId: 21,
  episodeNumber: 1,
})
```

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

### Query Documentation with 'ask' Parameter

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface.md

To get specific information not directly on a page, make an HTTP GET request to the page URL with the 'ask' query parameter. The question should be in natural language and specific.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface.md?ask=<question>
```

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

### Query Documentation with 'ask' Parameter

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library.md

To get additional information not directly present on a page, perform an HTTP GET request to the page URL with the 'ask' query parameter. The question should be specific and in natural language. The response will include an answer and relevant excerpts.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library.md?ask=<question>
```

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

### $debug.time

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/debug.md

Starts a named timer. If no label is provided, it defaults to 'default'.

```APIDOC
## time

`$debug.time(label?)`

Starts a named timer. If you omit the label, Seanime uses `"default"`.
```

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

### Get Studio Details

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/anilist.md

Fetches detailed information about a studio using its ID.

```typescript
/**
* Get studio details
*/
$anilist.getStudioDetails(studioId: number): $app.AL_StudioDetails
```

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

### Media Fillers - Get All

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/database.md

Retrieves all media filler data from the database.

```APIDOC
## Media Fillers - Get All

### Description
Retrieves all media filler data from the database.

### Method
GET

### Endpoint
$database.mediaFillers.getAll()

### Response
#### Success Response (200)
- **fillerData** (array) - An array of media filler objects.
```

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

### Auto Downloader Rules - Get All

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/database.md

Retrieves all configured auto-downloader rules.

```APIDOC
## Auto Downloader Rules - Get All

### Description
Retrieves all configured auto-downloader rules.

### Method
GET

### Endpoint
$database.autoDownloaderRules.getAll()

### Response
#### Success Response (200)
- **rules** (array) - An array of auto-downloader rule objects.
```

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

### Debrid Permissions Configuration

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/downloading/debrid.md

Example JSON configuration for granting 'debrid' scope and 'allow.writePaths' for downloads.

```json
{
  //...
  "plugin": {
    "permissions": {
      "scopes": ["debrid"],
      "allow": {
        "writePaths": ["$DOWNLOAD/**/*"]
      }
    }
  }
}
```

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

### Query Documentation via HTTP GET

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui.md

Use this method to ask specific questions about the documentation when the answer is not directly available on the page. The question should be in natural language.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/ui.md?ask=<question>
```

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

### Basic Store Operations

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/store.md

Demonstrates fundamental operations like setting, getting, watching, and removing values from the store.

```typescript
$store.set("foo", "bar")
$store.get("foo")
$store.watch("foo", (value) => {})
$store.getAll() // { "foo": "bar" }
$store.remove("foo")
$store.removeAll()
$store.has("foo") // false
$store.getOrSet("foo", () => { return "bar" })
$store.values() // ["bar"]
```

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

### Access Additional Directories

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/system/os.md

Get paths for desktop, document, and download directories. Ensure these are in the allow list for security.

```typescript
$osExtra.desktopDir()
$osExtra.documentDir()
$osExtra.downloadDir()
```

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

### Play Local File

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/videocore.md

Starts playback of a local file that has been scanned into Seanime's library. Progress tracking is enabled. The promise resolves once playback is initiated.

```typescript
await ctx.videoCore.playLocalFile("/anime/One Piece/One Piece - 1015.mkv")
```

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

### Plugin Initialization with Type Definitions

Source: https://seanime.gitbook.io/seanime-extensions/plugins/write-test-share.md

Shows how to set up a plugin with necessary type references and register a UI context callback for when the page loads.

```typescript
/// <reference path="./plugin.d.ts" />
/// <reference path="./system.d.ts" />
/// <reference path="./app.d.ts" />
/// <reference path="./core.d.ts" />

function init() {
    // Everything is magically typed!
    
    $ui.register((ctx) => {
    
      ctx.dom.onReady(() => {
          console.log("Page loaded!")
      })
      
   })
}
```

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

### Storage API Usage

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/storage.md

Demonstrates basic usage of the Storage API for setting, checking, and getting values, including nested keys and type casting.

```typescript
$storage.set("foo.bar", 1)
$storage.set("foo.baz", "2")

$storage.has("foo") // true

$storage.get<number>("foo.bar") // 1
$storage.get<Record<string, any>>("foo") // { "bar": 1, "baz": "2" }

$storage.set("foo", "bar")
$storage.get("foo") // bar

$storage.watch("foo", (value) => {})
```

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

### File System Operations Example

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/system/os.md

Demonstrates reading, writing, creating, listing, renaming, and removing files and directories. Ensure relevant paths are in the allow list. Always call `close()` when done with a file.

```typescript
// C:\Users\user\Downloads\test.txt
Hello World!

// my-plugin.ts
// "C:/Users/user/Downloads/**/*" and "$TEMP/**/*" have been added to 'allowReadPaths' and 'allowWritePaths'

// Access the temp directory
const tempDirPath = $os.tempDir();
console.log("Temp dir:", tempDirPath);

// Read files
const content = $os.readFile("C:\Users\user\Downloads\test.txt");
console.log("File content:", $toString(content)); // Hello World!

// Write/create files
$os.writeFile("C:\Users\user\Downloads\test.txt.new", $toBytes("New content"), 0644);
const newContent = $os.readFile("C:\Users\user\Downloads\test.txt.new");
console.log("New file content:", $toString(newContent)); // New content

// Read directories
const entries = $os.readDir("C:\Users\user\Downloads");
for (const entry of entries) {
	console.log(entry.name()); // test.txt, test.txt.new
}

// Create directories
$os.mkdir("C:\Users\user\Downloads\newdir", 0755);
const newEntries = $os.readDir("C:\Users\user\Downloads");
for (const entry of newEntries) {
	console.log(entry.name()); // test.txt, test.txt.new, newdir
}

// Rename files
$os.rename("C:\Users\user\Downloads\test.txt.new", "C:\Users\user\Downloads\test.txt.renamed");
let renameSuccess = true
try {
	// File exists, no error thrown
	$os.stat("C:\Users\user\Downloads\test.txt.renamed");
} catch(e) {
	renameSuccess = false
}
console.log(renameSuccess); // true

// Remove files
$os.remove("C:\Users\user\Downloads\test.txt.renamed");
let removeSuccess = true;
try {
	$os.stat("C:\Users\user\Downloads\test.txt.renamed");
	removeSuccess = false;
} catch (e) {
	// Error thrown becuase file should not exist
	removeSuccess = true;
}
console.log(removeSuccess); // true
```

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

### Get Parent Element

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/dom.md

Use getParent to retrieve the direct parent of a given DOM element. This is useful for navigating up the DOM tree, for example, to access properties of a parent list item.

```typescript
const listItem = await ctx.dom.queryOne("li.active")
const list = await listItem.getParent()
console.log(`Parent element tag: ${list.tagName}`)
```

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

### Start Torrent Stream

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/torrentstream.md

Initiates a torrent stream with specified options. Requires 'clientId' if using 'nativeplayer' or 'externalPlayerLink' playback types.

```typescript
await ctx.torrentstream.startStream({
  mediaId: 21,
  episodeNumber: 1,
  aniDbEpisode: "1",
  playbackType: "default",
  autoSelect: true,
})
```

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

### Initialize Webview with Preact and State Management

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/webview.md

This example initializes a webview panel, registers state variables for media and notes, and sets up communication channels between the extension and the webview. It uses Preact for rendering the UI within the webview.

```typescript
function init() {
    $ui.register((ctx) => {
        // In a real plugin, you'd likely load this from whatever resource
        const currentMedia = ctx.state({
            id: 101,
            title: "Frieren: Beyond Journey's End",
            cover: "https://s4.anilist.co/file/anilistcdn/media/anime/cover/large/bx154587-qQTzQnEJJ3oB.jpg"
        })

        const notes = ctx.state<Array<{ id: string, text: string, checked: boolean }>>([
            { id: "2", text: "Check discussion for latest episode", checked: true },
            { id: "1", text: "Watch the next season", checked: false },
        ])

        // Create the Webview
        const panel = ctx.newWebview({
            slot: "screen",
            fullWidth: true,
            autoHeight: true,
            sidebar: {
                label: "Notepad",
                icon: `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"><rect x="8" y="2" width="8" height="4" rx="1" ry="1"/></svg>`,
            },
        })

        // Setup Communication
        // Automatically keep 'notes' and 'currentMedia' variables in sync with the webview
        panel.channel.sync("notes", notes)
        panel.channel.sync("media", currentMedia)

        // Handle events sent from the webview
        panel.channel.on("add-note", (text) => {
            console.log("Received note:", text)
            const newNote = { id: Date.now().toString(), text, checked: false }
            // Updating this state automatically sends the new value to the webview thanks to .sync()
            notes.set([...notes.get(), newNote])
            ctx.toast.success("Note added")
        })

        panel.channel.on("toggle-note", (id) => {
            notes.set(prev => prev.map(n => n.id === id ? { ...n, checked: !n.checked } : n))
        })

        panel.channel.on("delete-note", (id) => {
            notes.set(prev => prev.filter(n => n.id !== id))
        })

        // Render the UI
        panel.setContent(() => `
        <!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <style>
                html { color-scheme: dark; overflow: hidden; }
                :root { 
                --bg: #101010; 
                --card: #10161f; 
                --text: #e2e8f0;
                --accent: #3b82f6;
                 }
                body { background: transparent; color: var(--text); font-family: -apple-system, system-ui, sans-serif; padding: 20px; margin: 0; }
                .container { max-width: 100%; margin: 0 auto; background: var(--card); border-radius: 12px; padding: 24px; box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1); }
                .header { display: flex; align-items: center; gap: 16px; margin-bottom: 24px; }
                .cover { width: 60px; height: 85px; border-radius: 6px; object-fit: cover; }
                h2 { margin: 0; font-size: 1.25rem; }
                
                .input-group { display: flex; gap: 8px; margin-bottom: 20px; }
                input {
                    flex: 1;
                    background: rgba(0,0,0,0.2);
                    border: 1px solid rgba(255,255,255,0.1);
                    color: white;
                    padding: 8px 12px;
                    border-radius: 6px;
                }
                button { background: var(--accent); color: white; border: none; padding: 8px 16px; border-radius: 6px; cursor: pointer; font-weight: 500; }
                button:hover { opacity: 0.9; }
                
                .list { list-style: none; padding: 0; margin: 0; }
                .item { display: flex; align-items: center; gap: 12px; padding: 12px; border-bottom: 1px solid rgba(255,255,255,0.05); }
                .item:last-child { border-bottom: none; }
                .item.checked span { text-decoration: line-through; opacity: 0.5; }
                .delete-btn { background: transparent; color: #ef4444; padding: 4px; margin-left: auto; opacity: 0;

```

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

### Get AniList Username

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/database.md

Retrieves the authenticated AniList username. This method is used to get the current user's AniList identifier.

```typescript
$database.anilist.getUsername()
```

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

### Get OS Platform and Architecture

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/system/os.md

Retrieve the operating system's platform (e.g., 'darwin', 'win32', 'linux') and architecture (e.g., 'x64', 'arm64').

```typescript
console.log("Platform:", $os.platform);
console.log("Arch:", $os.arch);
```

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

### Query Documentation with Agent

Source: https://seanime.gitbook.io/seanime-extensions/seanime

To ask questions about the documentation, perform an HTTP GET request on the current page URL with the 'ask' query parameter. The question should be specific and in natural language.

```http
GET https://seanime.gitbook.io/seanime-extensions/seanime.md?ask=<question>
```

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

### Get Collections

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/anilist.md

Retrieves the user's anime and manga collections, with options to get raw data or data including lists with no status.

```APIDOC
## Get Collections

### Description
Retrieves the user's anime and manga collections. Options include getting raw data or data that includes lists with no status.

### Methods
- `getAnimeCollection(bypassCache: boolean): $app.AL_AnimeCollection`
- `getRawAnimeCollection(bypassCache: boolean): $app.AL_AnimeCollection`
- `getMangaCollection(bypassCache: boolean): $app.AL_MangaCollection`
- `getRawMangaCollection(bypassCache: boolean): $app.AL_MangaCollection`
- `getAnimeCollectionWithRelations(): $app.AL_AnimeCollectionWithRelations`
```

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

### Initiating and Tracking Downloads in TypeScript

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/downloading/downloader.md

This TypeScript code demonstrates how to start a download to a specified file path, track its progress using a callback function, and handle completion or errors. It also shows how to cancel an ongoing download.

```typescript
//...

// Destination file
// Note that $DOWNLOAD is in the allow list
const filePath = $filepath.Join($osExtra.downloadDir(), "file.zip")
const downloadUrl = "http://example.com/download/file.zip"

// Start a download
const downloadID = ctx.downloader.download(downloadUrl, filePath);

// Track progress
const cancelWatch = ctx.downloader.watch(downloadID, (progress) => {
	console.log("Download progress:", 
		progress.percentage.toFixed(2), "%, ", 
		"Speed:", (progress.speed / 1024).toFixed(2), "KB/s, ",
		"Downloaded:", (progress.totalBytes / 1024).toFixed(2), "KB"
	);
	
	if (progress.status === "completed") {
		// download completed
	} else if (progress.status === "error") {
		// something went wrong
	}
});

// Cancel at any time
ctx.downloader.cancel(downloadID)
```

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

### Bootstrap Manga Provider Template

Source: https://seanime.gitbook.io/seanime-extensions/content-providers/manga-provider.md

Use this command-line tool to quickly bootstrap a new manga provider folder locally.

```bash
npx seanime-tool g-template
```

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

### Querying Seanime Documentation

Source: https://seanime.gitbook.io/seanime-extensions/seanime/readme.md

To get additional information not directly present on a page, perform an HTTP GET request to the page URL with the 'ask' query parameter. The question should be specific and in natural language.

```http
GET https://seanime.gitbook.io/seanime-extensions/seanime/readme.md?ask=<question>
```

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

### Register UI Context with $app Helpers

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/helpers.md

Demonstrates how to use $app helpers within the UI context, such as getting the application version, version name, invalidating client queries, and retrieving client IDs and platforms.

```typescript
$ui.register((ctx) => {

    $app.getVersion() // "3.7.0"
    $app.getVersionName() // "Gold"
    
    // Invalidate certain queries to cause the client to refetch them automatically
    // Find the query keys here: https://github.com/5rahim/seanime/blob/main/internal/events/endpoints.go
    $app.invalidateClientQuery([])
    
    $app.getClientIds() // Returns the client IDs
    $app.getClientPlatform("id") // Returns the platform, "web", "denshi"

})
```

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

### Query Documentation Dynamically

Source: https://seanime.gitbook.io/seanime-extensions/content-providers

Use this method to ask questions about the documentation. The response includes direct answers and relevant excerpts.

```HTTP
GET https://seanime.gitbook.io/seanime-extensions/content-providers.md?ask=<question>
```

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

### Log Scan Completion Duration (Recommended)

Source: https://seanime.gitbook.io/seanime-extensions/plugins/hooks.md

This example shows the recommended practice for handling events like scan completion. Instead of performing business logic directly in the hook, it stores a copy of the event data in `$store` and then uses `$ui.register` with `$store.watch` to process the data and display a toast message. This defers the business logic to the UI context.

```typescript
// ✅ Good practice: Defer business logic to the UI context
function init() {
    $app.onScanCompleted((e) => {
        // Send a copy of the event
        $store.set("scan-completed", $clone(e))
        e.next()
    })
    
    // Let the UI context "listen" to the event and execute business logic
    $ui.register((ctx) => {
        // Callback is triggered anytime 'set' is called on that key
        $store.watch<number>("scan-completed", (e) => {
            const now = new Date().toISOString().replaceall(".", "_")
            
            // Add the value to the history
            $storage.set("scan-duration-history."+now, e.duration)
            
            ctx.toast.info(`Scanning took ${e.duration/1000} seconds!`)
        })
    })
}
```

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

### System Allow List Configuration

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/system/permissions.md

Configure 'systemAllowList' to specify which paths plugins can read from or write to, and which commands they can execute. This is crucial for security when Extension Secure Mode is enabled.

```json
{
    //...
    "plugin": {
        "permissions": ["system", ...],
        "systemAllowList": {
            "allowReadPaths": ["$TEMP/*"],
            "allowWritePaths": ["$TEMP/*"],
            "commandScopes": []
        }
    }
}
```

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

### Query Documentation Page

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/downloading.md

To ask questions about the documentation, perform an HTTP GET request on the page URL with the 'ask' query parameter. The question should be specific and in natural language.

```HTTP
GET https://seanime.gitbook.io/seanime-extensions/plugins/ui/downloading.md?ask=<question>
```

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

### cancelPreparedStream

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/torrentstream.md

Cancels a torrent stream that has been prepared but not yet started.

```APIDOC
## cancelPreparedStream

### Description
Cancels a prepared torrent stream, if one exists.

### Method
POST

### Endpoint
ctx.torrentstream.cancelPreparedStream()

### Parameters
None

### Response
#### Success Response (200)
- **status** (string) - Indicates the result of the operation (e.g., "cancelled").

### Response Example
```json
{
  "status": "cancelled"
}
```
```

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

### getNextEpisode

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/playback-external.md

Gets the next episode to play after the current one.

```APIDOC
## getNextEpisode

### Description
Gets the next episode to play after the current one.

### Method
INVOKE

### Endpoint
ctx.playback.getNextEpisode()

### Response
#### Success Response
Returns the next episode object if available, otherwise null.
- **nextEpisode** (Object | null) - Description of the next episode or null if none available.

### Response Example
```typescript
const nextEpisode = await ctx.playback.getNextEpisode()
if (nextEpisode) {
  console.log(`Next episode: ${nextEpisode.name}`)
} else {
  console.log("No next episode available")
}
```
```

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

### Concrete Online Streaming Provider Implementation

Source: https://seanime.gitbook.io/seanime-extensions/content-providers/online-streaming-provider.md

A concrete implementation of the AnimeProvider abstract class, demonstrating how to provide settings, search for anime, find episodes, and retrieve video sources.

```typescript
/// <reference path="./online-streaming-provider.d.ts" />
 
class Provider {

    getSettings(): Settings {
        return {
            episodeServers: ["server1", "server2"],
            supportsDub: true,
        }
    }

    async search(query: SearchOptions): Promise<SearchResult[]> {
        return [{
            id: "1",
            title: "Anime Title",
            url: "https://example.com/anime/1",
            subOrDub: "both",
        }]
    }
    async findEpisodes(id: string): Promise<EpisodeDetails[]> {
        return [{
            id: "1",
            number: 1,
            url: "https://example.com/episode/1",
            title: "Episode title",
        }]
    }
    async findEpisodeServer(episode: EpisodeDetails, _server: string): Promise<EpisodeServer> {
        let server = "server1"
        if (_server !== "default") server = _server
        
        return {
            server: server,
            headers: {},
            videoSources: [{
                url: "https://example.com/.../stream.m3u8",
                type: "m3u8",
                quality: "1080p",
                subtitles: [{
                    id: "1",
                    url: "https://example.com/.../subs.vtt",
                    language: "en",
                    isDefault: true,
                }],
            }],
        }
    }
}
```

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

### AniList - Get Username

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/database.md

Retrieves the authenticated AniList username.

```APIDOC
## AniList - Get Username

### Description
Retrieves the authenticated AniList username.

### Method
GET

### Endpoint
$database.anilist.getUsername()

### Response
#### Success Response (200)
- **username** (string) - The AniList username.
```

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

### Webview Event Handling and Control

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/webview.md

Demonstrates common event listeners for webviews (onMount, onUnmount, onLoad) and methods for updating, getting the screen path, hiding, and showing the webview.

```typescript
webview.onMount(() => {
    // Webview has been mounted on the screen
})

webview.onUnmount(() => {
    // Webview has been unmounted
})

webview.onLoad(() => {
    // Webview content has been loaded (after mount)
})

// Force the webview content to update
webview.update()

// Returns the path to the webview screen
webview.getScreenPath() // /webview?id=my-plugin

webview.hide()

webview.show()
```

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

### Cache and State Management Example

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/helpers.md

Demonstrates using ctx.cache.getOrSet for data fetching and caching, and ctx.state for managing UI state. It also shows how to update cache and state based on navigation events and effects. Cache entries can have a Time-To-Live (TTL).

```typescript
$ui.register((ctx) => {
    const currentMediaId = ctx.state<number | null>(null)
    const currentTitle = ctx.state("Open an anime entry")

    ctx.screen.onNavigate((event) => {
        if (event.pathname === "/entry" && event.searchParams.id) {
            currentMediaId.set(parseInt(event.searchParams.id))
            return
        }

        currentMediaId.set(null)
        currentTitle.set("Open an anime entry")
        ctx.cache.remove("current-entry")
    })

    ctx.effect(async () => {
        const mediaId = currentMediaId.get()
        if (!mediaId) {
            return
        }

        const animeEntry = await ctx.cache.getOrSet(
            `anime-entry:${mediaId}`,
            () => ctx.anime.getAnimeEntry(mediaId),
            { ttl: 60_000 },
        )

        currentTitle.set(animeEntry?.media?.title?.userPreferred ?? "Unknown title")

        ctx.cache.set("current-entry", {
            mediaId,
            loadedAt: Date.now(),
        }, 5_000)

        console.log("cache size", ctx.cache.size())
    }, [currentMediaId])

    ctx.screen.loadCurrent()
})
```

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

### Create a Basic Webview Panel

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/webview.md

Creates a webview panel that appears below the home screen toolbar. It is configured to take up the full width and adjust its height automatically.

```typescript
// Create a panel that appears below the home screen toolbar
const panel = ctx.newWebview({
    slot: "after-home-screen-toolbar",
    fullWidth: true,
    autoHeight: true,
})
```

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

### getSettings

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/auto-downloader.md

Returns the current auto-downloader settings, or `undefined` if the feature is not configured.

```APIDOC
## getSettings

### Description
Returns the current auto-downloader settings, or `undefined` if the feature is not configured.

### Method
`getSettings()`

### Returns
`$app.Models_AutoDownloaderSettings | undefined`

### Request Example
```typescript
const settings = ctx.autoDownloader.getSettings()
console.log(settings)
```
```

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

### Auto Downloader Items - Get All

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/database.md

Retrieves all items currently in the auto-downloader queue.

```APIDOC
## Auto Downloader Items - Get All

### Description
Retrieves all items currently in the auto-downloader queue.

### Method
GET

### Endpoint
$database.autoDownloaderItems.getAll()

### Response
#### Success Response (200)
- **items** (array) - An array of auto-downloader item objects.
```

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

### Query GitBook Documentation

Source: https://seanime.gitbook.io/seanime-extensions/plugins/hooks.md

Use this method to ask questions about the documentation dynamically. The question should be specific and in natural language.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/hooks.md?ask=<question>
```

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

### Local Files - Get All

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/database.md

Retrieves all scanned local file entries from the database.

```APIDOC
## Local Files - Get All

### Description
Retrieves all scanned local file entries from the database.

### Method
GET

### Endpoint
$database.localFiles.getAll()

### Response
#### Success Response (200)
- **localFiles** (array) - An array of local file objects.
```

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

### Query Documentation via HTTP

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/screen.md

Perform an HTTP GET request to query the documentation dynamically. This is useful when the answer is not explicitly present on the page, requires clarification, or needs additional context.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/screen.md?ask=<question>
```

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

### Get File Extension

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/system/filepath.md

Extracts the file extension from a given file path.

```typescript
const extName = $filepath.ext("C:\\Users\\user\\Downloads\\file.mkv");
console.log(extName); // .mkv
```

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

### startStream

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/torrentstream.md

Initiates a torrent stream with specified options. Requires 'playback' permission.

```APIDOC
## startStream

### Description
Starts a torrent stream. If `playbackType` is `"nativeplayer"` or `"externalPlayerLink"`, `clientId` is required.

### Method
POST

### Endpoint
ctx.torrentstream.startStream(options)

### Parameters
#### Request Body
- **options** (object) - Required
  - **mediaId** (Number) - Required
  - **episodeNumber** (Number) - Required - Relative episode number
  - **aniDbEpisode** (String) - Required - AniDB episode identifier
  - **playbackType** ("default" | "externalPlayerLink" | "nativeplayer" | "none" | "noneAndAwait") - Required
  - **autoSelect** (Boolean) - Optional
  - **torrent** ($app.HibikeTorrent_AnimeTorrent) - Optional manual selection
  - **fileIndex** (Number) - Optional manual file index
  - **userAgent** (String) - Optional
  - **clientId** (String) - Optional unless required by the playback type
  - **batchEpisodeFiles** (TorrentstreamBatchEpisodeFiles) - Optional

### Request Example
```json
{
  "mediaId": 21,
  "episodeNumber": 1,
  "aniDbEpisode": "1",
  "playbackType": "default",
  "autoSelect": true
}
```

### Response
#### Success Response (200)
- **streamId** (String) - Identifier for the started stream.

#### Response Example
```json
{
  "streamId": "some-stream-id"
}
```
```

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

### getPreviousStreamOptions

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/torrentstream.md

Retrieves the options used for the most recent torrent stream, or undefined if no stream has been started.

```APIDOC
## getPreviousStreamOptions

### Description
Returns the previous torrentstream start options, or `undefined` if no stream has been started yet.

### Method
GET

### Endpoint
ctx.torrentstream.getPreviousStreamOptions()

### Parameters
None

### Response
#### Success Response (200)
- **options** (object | undefined) - The previous stream options or undefined.

### Response Example
```json
{
  "options": {
    "mediaId": 21,
    "episodeNumber": 1,
    "aniDbEpisode": "1",
    "playbackType": "default",
    "autoSelect": true
  }
}
```
```

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

### Media Fillers - Get

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/database.md

Retrieves media filler data for a specific media ID.

```APIDOC
## Media Fillers - Get

### Description
Retrieves media filler data for a specific media ID.

### Method
GET

### Endpoint
$database.mediaFillers.get(mediaId)

### Parameters
#### Path Parameters
- **mediaId** (number) - Required - The ID of the media to retrieve filler data for.

### Response
#### Success Response (200)
- **fillerData** (object) - The media filler data for the specified media ID.
```

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

### Silenced Media Entries - Get All IDs

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/database.md

Retrieves a list of all media IDs that have been silenced.

```APIDOC
## Silenced Media Entries - Get All IDs

### Description
Retrieves a list of all media IDs that have been silenced.

### Method
GET

### Endpoint
$database.silencedMediaEntries.getAllIds()

### Response
#### Success Response (200)
- **silencedIds** (array) - An array of media IDs that are silenced.
```

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

### Initialize Plugin

Source: https://seanime.gitbook.io/seanime-extensions/plugins/write-test-share.md

The init function is called when the plugin is loaded. There is no guarantee as to when exactly the plugin will be loaded at startup.

```typescript
function init() {
    // This function is called when the plugin is loaded
    // There is no guarantee as to when exactly the plugin will be loaded at startup
}
```

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

### Get Manga by ID

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/anilist.md

Fetches basic manga information using its unique ID.

```typescript
/**
* Get manga by ID
*/
$anilist.getManga(id: number): $app.AL_BaseManga
```

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

### onMainTabReady

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/user-interface/dom.md

Executes a callback when the main tab becomes ready, or for each new main tab that appears. This runs immediately after onReady.

```APIDOC
## onMainTabReady

### Description
Executes a callback when the the main tab is ready or each time there is a new main tab. It will run right after `onReady`.

### Parameters
* `callback`: Function to execute

### Example
```typescript
ctx.dom.onMainTabReady(() => {
  console.log("Main tab is ready...")
})
```
```

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

### AniList - Get Token

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/database.md

Retrieves the AniList authentication token. Requires the `anilist-token` permission.

```APIDOC
## AniList - Get Token

### Description
Retrieves the AniList authentication token. Requires the `anilist-token` permission.

### Method
GET

### Endpoint
$database.anilist.getToken()

### Permissions
- `anilist-token`

### Response
#### Success Response (200)
- **token** (string) - The AniList authentication token.
```

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

### Query Documentation Dynamically

Source: https://seanime.gitbook.io/seanime-extensions/frequently-asked

Use this method to ask specific questions about the documentation when the answer is not explicitly present on the current page. The response includes a direct answer, relevant excerpts, and sources.

```http
GET https://seanime.gitbook.io/seanime-extensions/frequently-asked.md?ask=<question>
```

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

### Get Anime by ID

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/anilist.md

Fetches basic anime information using its unique ID.

```typescript
/**
* Get anime by ID
*/
$anilist.getAnime(id: number): $app.AL_BaseAnime
```

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

### Get All Watch History Items

Source: https://seanime.gitbook.io/seanime-extensions/plugins/ui/anime-library/continuity.md

Retrieves all recorded watch progress items for all anime.

```typescript
const items = ctx.continuity.getWatchHistory()
```

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

### Query Anilist Documentation

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/anilist.md

Perform an HTTP GET request to query the documentation dynamically. Use the 'ask' query parameter with a natural language question for specific information.

```http
GET https://seanime.gitbook.io/seanime-extensions/plugins/apis/anilist.md?ask=<question>
```

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

### Get Directory Name of a Filepath

Source: https://seanime.gitbook.io/seanime-extensions/plugins/apis/system/filepath.md

Extracts the directory name from a given file path.

```typescript
const dirName = $filepath.dir("C:\\Users\\user\\Downloads\\file.mkv");
console.log(dirName); // C:\\Users\\user\\Donwloads
```