@xingjisoft/neutrino 0.6.2 → 0.7.0

package/dist/screens/settings.d.ts

@@ -0,0 +1,42 @@
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+export declare class SettingsScreen extends Screen {
+    private intensityIdx;
+    /** Levels the current chat model accepts, in canonical order. */
+    private intensityLevels;
+    private contextTokens;
+    private contextChanged;
+    /** 0 = same model as the chat, otherwise index + 1 into `models`. */
+    private approvalModelIdx;
+    /** 0 = off (human only), 1 = on (two independent assessments). */
+    private extremeIdx;
+    /** 0 = silent, 1 = audible cue on turn end and on approval requests. */
+    private soundIdx;
+    /** 0 = web UI off, 1 = mounted alongside the terminal. */
+    private webIdx;
+    /** 0 = terminal only, 1 = the Web console is run by a detached service. */
+    private backgroundIdx;
+    /** Only a row the user actually touched rewrites the saved default. */
+    private webChanged;
+    private backgroundPending;
+    private models;
+    private rowIdx;
+    private lastHoverX;
+    private lastHoverY;
+    private editingPassword;
+    private passwordDraft;
+    private passwordMessage;
+    onActivate(): void;
+    /** Change the value of a row by `delta` steps and persist it immediately. */
+    private cycle;
+    private applyBackground;
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    onPaste(text: string): void;
+    onDeactivate(): void;
+    private rowTexts;
+    private layout;
+    private save;
+    render(buf: Buffer): void;
+}

package/dist/screens/start.d.ts

@@ -0,0 +1,43 @@
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+export declare class StartScreen extends Screen {
+    private extensions;
+    private get tabs();
+    private get focusCount();
+    onActivate(): void;
+    private get approvalMode();
+    private toggleApproval;
+    private logoLines;
+    private inputValue;
+    private cursor;
+    private focusIdx;
+    private hoverIdx;
+    private proHover;
+    private webHover;
+    private lastHoverX;
+    private lastHoverY;
+    showsCursor(): boolean;
+    onPaste(text: string): void;
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    /**
+     * The message box, the tabs below it and the hint row are persistent chrome;
+     * repainting them every frame keeps them self-healing against terminal-side
+     * drift (see Screen.alwaysRepaintRows).
+     */
+    alwaysRepaintRows(): number[];
+    private layout;
+    /**
+     * First content row. The centered block normally floats in the middle, but
+     * it must start below the top-left buttons when they are visible: the boxes
+     * are opaque chrome and would otherwise clip the top of the logo.
+     */
+    private contentTop;
+    private move;
+    /** Move the text cursor by one character, staying within bounds and on
+     *  surrogate-pair boundaries. */
+    private moveCursor;
+    private enterTab;
+    render(buf: Buffer): void;
+}

package/dist/screens/start.js

@@ -1,17 +1,21 @@
+import { terminalUI } from "../plugins/terminal.js";
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { loadLogo, loadVersion, loadConfig, saveConfig, normalizeApprovalMode } from "../config.js";
 import { drawHeader } from "../header.js";
 import { centerVertically, computeInputWindow, cursorFromColumn, drawHint, drawInputBox, drawTabButton, inRect, approvalToggle, drawApprovalToggle, drawHeaderButton, proModeButton, webModeButton, } from "../ui.js";
-const TABS = ["Model", "History", "Settings"];
+const TABS = ["Model", "History", "Settings", "Plugins"];
 const LOGO = loadLogo();
-const FOCUS_COUNT = TABS.length + 2; // input box + 3 tabs + approval mode
 const INPUT_H = 3;
 const TAB_H = 3;
 function isLowSurrogate(code) {
     return code >= 0xdc00 && code <= 0xdfff;
 }
 export class StartScreen extends Screen {
+    extensions = [];
+    get tabs() { return [...TABS, ...this.extensions.slice(0, Math.max(0, Math.floor(((this.app?.width ?? 80) - 2) / 10) - TABS.length)).map(item => item.title)]; }
+    get focusCount() { return this.tabs.length + 2; }
+    onActivate() { this.extensions = terminalUI().filter(item => item.slot === "app.menu" || item.slot === "workspace.tabs"); }
     get approvalMode() {
         return normalizeApprovalMode(loadConfig().approval_mode);
     }
@@ -81,7 +85,7 @@ export class StartScreen extends Screen {
                 if (text)
                     this.app.startNewChat(text);
             }
-            else if (this.focusIdx === FOCUS_COUNT - 1) {
+            else if (this.focusIdx === this.focusCount - 1) {
                 this.toggleApproval();
             }
             else {
@@ -149,7 +153,7 @@ export class StartScreen extends Screen {
             // must not light up.
             if (!proHover && !webHover) {
                 if (inRect(ev.x, ev.y, approvalToggle(this.app.width, this.app.height - 4, this.approvalMode))) {
-                    hover = FOCUS_COUNT - 1;
+                    hover = this.focusCount - 1;
                 }
                 else if (layout && inRect(ev.x, ev.y, { x: layout.inputX, y: layout.inputY, w: layout.inputW, h: INPUT_H })) {
                     hover = 0;
@@ -191,7 +195,7 @@ export class StartScreen extends Screen {
                 return;
             }
             if (ev.y >= 1 && inRect(ev.x, ev.y, approvalToggle(this.app.width, this.app.height - 4, this.approvalMode))) {
-                this.focusIdx = FOCUS_COUNT - 1;
+                this.focusIdx = this.focusCount - 1;
                 this.toggleApproval();
                 return;
             }
@@ -256,12 +260,12 @@ export class StartScreen extends Screen {
         const inputY = this.contentTop(h, contentH) + logoLines.length + logoGap;
         const tabY = inputY + INPUT_H + gap;
         const tabGap = 2;
-        const tabInner = inputW - tabGap * (TABS.length - 1);
-        const baseW = Math.floor(tabInner / TABS.length);
-        const extra = tabInner - baseW * TABS.length;
+        const tabInner = inputW - tabGap * (this.tabs.length - 1);
+        const baseW = Math.floor(tabInner / this.tabs.length);
+        const extra = tabInner - baseW * this.tabs.length;
         const tabs = [];
         let tx = inputX;
-        for (let i = 0; i < TABS.length; i++) {
+        for (let i = 0; i < this.tabs.length; i++) {
             const tw = baseW + (i < extra ? 1 : 0);
             tabs.push({ x: tx, w: tw });
             tx += tw + tabGap;
@@ -279,7 +283,7 @@ export class StartScreen extends Screen {
         return pro ? Math.max(top, pro.y + pro.h) : top;
     }
     move(delta) {
-        this.focusIdx = (this.focusIdx + delta + FOCUS_COUNT) % FOCUS_COUNT;
+        this.focusIdx = (this.focusIdx + delta + this.focusCount) % this.focusCount;
         this.hoverIdx = -1;
         this.app.render();
     }
@@ -306,8 +310,12 @@ export class StartScreen extends Screen {
             this.app.openModelConfig();
         else if (this.focusIdx === 2)
             this.app.openHistory();
-        else
+        else if (this.focusIdx === 3)
             this.app.openSettings();
+        else if (this.focusIdx === 4)
+            this.app.openPlugins();
+        else if (this.extensions[this.focusIdx - 5])
+            this.app.openPluginContribution(this.extensions[this.focusIdx - 5]);
     }
     render(buf) {
         drawHeader(buf, this.app.state);
@@ -335,14 +343,14 @@ export class StartScreen extends Screen {
         });
         y += INPUT_H + gap;
         const tabGap = 2;
-        const tabInner = inputW - tabGap * (TABS.length - 1);
-        const baseW = Math.floor(tabInner / TABS.length);
-        const extra = tabInner - baseW * TABS.length;
+        const tabInner = inputW - tabGap * (this.tabs.length - 1);
+        const baseW = Math.floor(tabInner / this.tabs.length);
+        const extra = tabInner - baseW * this.tabs.length;
         let tx = inputX;
-        for (let i = 0; i < TABS.length; i++) {
+        for (let i = 0; i < this.tabs.length; i++) {
             const tw = baseW + (i < extra ? 1 : 0);
             const selected = i === this.focusIdx - 1 || i === this.hoverIdx - 1;
-            drawTabButton(buf, tx, y, tw, TABS[i], selected);
+            drawTabButton(buf, tx, y, tw, this.tabs[i], selected);
             tx += tw + tabGap;
         }
         // The version label is pinned one row above the very bottom of the screen,
@@ -363,7 +371,7 @@ export class StartScreen extends Screen {
         if (showVersion) {
             buf.centerText(versionY, `v${version}`, { fg: C.dim });
         }
-        drawApprovalToggle(buf, approvalY, this.approvalMode, this.focusIdx === FOCUS_COUNT - 1 || this.hoverIdx === FOCUS_COUNT - 1);
+        drawApprovalToggle(buf, approvalY, this.approvalMode, this.focusIdx === this.focusCount - 1 || this.hoverIdx === this.focusCount - 1);
         // Painted last so their opaque footprints are never clipped by the
         // decorative content drawn before them. Hit testing shares the geometry.
         drawHeaderButton(buf, proModeButton(w, h), this.proHover);

package/dist/screens/updatePrompt.d.ts

@@ -0,0 +1,41 @@
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+import { type UpdateStatus } from "../update.js";
+/**
+ * The "a newer Neutrino is published" notice.
+ *
+ * It is pushed over the start screen only, never over a conversation: the
+ * answer arrives a moment after launch, and stealing a chat the user has
+ * already opened would be worse than a missed notice.
+ *
+ * Confirming runs npm here, in this process; the running code is not replaced,
+ * so a successful update ends by telling the user to restart. A failed one
+ * shows the command to run by hand, because npm usually fails for a reason the
+ * user has to fix (permissions, a proxy, an offline machine).
+ */
+export declare class UpdatePromptScreen extends Screen {
+    private phase;
+    /** Why the install failed, or which version landed. */
+    private detail;
+    private selectedIdx;
+    private lastHoverX;
+    private lastHoverY;
+    private readonly current;
+    private readonly latest;
+    constructor(status: UpdateStatus);
+    /** The buttons drawn right now; a click always lands on one of these. */
+    private buttons;
+    private buttonRow;
+    /** Columns the body paragraphs may use before wrapping. */
+    private bodyWidth;
+    private start;
+    private close;
+    private activate;
+    private move;
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    /** What the dialog says, in the order it is drawn. */
+    private body;
+    render(buf: Buffer): void;
+}

package/dist/selection.d.ts

@@ -0,0 +1,75 @@
+import type { Buffer } from "./terminal/buffer.js";
+export interface Point {
+    x: number;
+    y: number;
+}
+/** A point in *content* space: a line of the scrollable log, plus a column. */
+export interface LinePoint {
+    line: number;
+    x: number;
+}
+/**
+ * A mouse text selection. `anchor` is the cell where the drag started and
+ * `cursor` is the cell currently under the pointer; either may be above/left of
+ * the other, so consumers normalise before use.
+ */
+export interface Selection {
+    anchor: Point;
+    cursor: Point;
+}
+/** Order the two ends of a selection into reading order (top-left first). */
+export declare function normalizeSelection(sel: Selection): {
+    start: Point;
+    end: Point;
+};
+/** Order the two ends of a line-space selection into reading order. */
+export declare function orderLinePoints(a: LinePoint, b: LinePoint): {
+    start: LinePoint;
+    end: LinePoint;
+};
+/**
+ * Paint the selection highlight directly onto the rendered buffer. Working on
+ * the buffer (rather than on each screen) means the highlight automatically
+ * follows whatever is on screen — chat output, the input box, menus, …
+ *
+ * Intermediate lines stop at the last non-blank cell so a multi-line selection
+ * doesn't paint a block out to the right edge of the terminal.
+ */
+export declare function applySelection(buf: Buffer, sel: Selection): void;
+/**
+ * Extract the plain text covered by a selection.
+ *
+ * Three kinds of cell are skipped so the result is clean, pasteable text:
+ *   - UI chrome (the scrollbar), which is never content;
+ *   - wide-character continuation cells (`""`), which would duplicate a CJK
+ *     glyph;
+ *   - trailing blanks, trimmed per line (shell-style).
+ *
+ * Intermediate lines are copied out to the buffer's full width and only then
+ * trimmed, which keeps indentation intact while dropping the padding on the
+ * right. Skipping the scrollbar *before* trimming is what lets that trim
+ * actually reach the end of the text instead of stopping at the bar.
+ */
+export declare function selectionText(buf: Buffer, sel: Selection): string;
+/**
+ * One buffer row as column-indexed text: `cells[x]` is what column `x` holds,
+ * or `""` for a cell that never copies (UI chrome, and the tail of a
+ * double-width glyph).
+ *
+ * Keeping the column index is the point: it lets a row be sliced by column
+ * later, after the frame it came from is long gone. A drag that scrolls the log
+ * needs exactly that, because the rows it started on leave the screen while the
+ * selection keeps growing.
+ */
+export declare function rowCells(buf: Buffer, y: number): string[];
+/**
+ * Extract the text of a selection expressed in content lines (`rowSelectionText`
+ * is to `selectionText` what `LinePoint` is to `Point`).
+ *
+ * `getRow` supplies the cells of a line — from the current frame while the line
+ * is on screen, from the snapshot taken during the drag once it has scrolled
+ * away, or `null` for a line that was never captured. Trailing blanks and edge
+ * blank lines are trimmed exactly like `selectionText`, so both paths produce
+ * the same text for a selection that fits on one screen.
+ */
+export declare function rowSelectionText(getRow: (line: number) => readonly string[] | null, start: LinePoint, end: LinePoint): string;

package/dist/state.d.ts

@@ -0,0 +1,26 @@
+import type { Selection } from "./selection.js";
+export interface AppState {
+    selectedProvider: string;
+    selectedModelName: string;
+    selectedModelUrl: string;
+    selectedModelApiKey: string;
+    selectedModelStreaming: boolean;
+    selectedIntensity: string;
+    isThinking: boolean;
+    /** Blink phase for the "thinking" indicator in the top status bar. */
+    blinkOn: boolean;
+    /** Blink phase for the text cursors (true = lit, false = hidden). */
+    cursorOn: boolean;
+    /** Pending human approval; while set the top bar turns orange. */
+    approval: {
+        tool: string;
+        level: "high" | "extreme";
+    } | null;
+    /** URL of the running browser UI, or null when it is not mounted. */
+    webUrl: string | null;
+    /** True when that console is owned by the detached background service. */
+    webBackground: boolean;
+    /** Active mouse text selection, or null when nothing is selected. */
+    selection: Selection | null;
+}
+export declare function defaultState(): AppState;

package/dist/terminal/buffer.d.ts

@@ -0,0 +1,47 @@
+import { type Style } from "../colors.js";
+export interface Cell {
+    ch: string;
+    style: Style;
+    /**
+     * True for UI chrome (scrollbars, borders, …). Chrome is drawn like any
+     * other cell, but is deliberately *not* copied: extracting a selection
+     * skips it, so a copied line never ends up with a scrollbar glued to its
+     * right edge.
+     */
+    chrome?: boolean;
+}
+export declare class Buffer {
+    width: number;
+    height: number;
+    cells: Cell[][];
+    constructor(width: number, height: number);
+    /**
+     * Write a single cell, keeping the wide-glyph invariant intact. The renderer
+     * (and the selection logic) rely on the rule that a `""` cell is *always* the
+     * right half of a double-width glyph at `x - 1`. If the invariant is broken an
+     * orphan tail is left behind: the renderer skips it, so that column is never
+     * repainted and a stale glyph from the previous frame stays on screen (the
+     * "residual line" bug). To preserve it we blank the *other* half whenever we
+     * overwrite one half of a wide glyph.
+     */
+    private overwriteCell;
+    /**
+     * Mark `x` as the tail (`""`) of the wide glyph at `x - 1`. Unlike
+     * `overwriteCell` this never blanks the cell to the left, because that cell is
+     * the glyph we are currently writing.
+     */
+    private writeTail;
+    private writeChar;
+    set(x: number, y: number, ch: string, style?: Style): void;
+    writeText(x: number, y: number, text: string, style?: Style): void;
+    centerText(y: number, text: string, style?: Style): void;
+    fillRect(x: number, y: number, w: number, h: number, style?: Style): void;
+    drawBox(x: number, y: number, w: number, h: number, style?: Style): void;
+    /**
+     * Flag a cell as non-copyable chrome (e.g. a scrollbar). The flag lives on
+     * the cell and is cleared automatically whenever the cell is written again,
+     * since every frame starts from a fresh buffer.
+     */
+    markChrome(x: number, y: number): void;
+    clear(): void;
+}

package/dist/terminal/input.d.ts

@@ -0,0 +1,70 @@
+export interface Key {
+    name: string;
+    ctrl: boolean;
+    meta: boolean;
+    shift: boolean;
+    char: string;
+    sequence: string;
+}
+export type MouseEvent = {
+    type: "wheel";
+    dir: -1 | 1;
+    x: number;
+    y: number;
+} | {
+    type: "click";
+    x: number;
+    y: number;
+    button: number;
+} | {
+    type: "move";
+    x: number;
+    y: number;
+    drag: boolean;
+} | {
+    type: "release";
+    x: number;
+    y: number;
+    button: number;
+};
+export type InputEvent = {
+    type: "key";
+    key: Key;
+} | {
+    type: "paste";
+    text: string;
+} | {
+    type: "mouse";
+    event: MouseEvent;
+};
+export declare class InputReader {
+    private decoder;
+    private pending;
+    private state;
+    private csiBuf;
+    private escTimer;
+    private inPaste;
+    private pasteBuf;
+    private handler;
+    private dataHandler;
+    start(handler: (ev: InputEvent) => void): void;
+    stop(): void;
+    private onData;
+    private process;
+    private scheduleEscTimeout;
+    private cancelEscTimeout;
+    private finishCsi;
+    /**
+     * Parse SGR (extended) mouse sequences: ESC [ < b ; x ; y M/m
+     *
+     * `b` is a bit field: the low two bits are the button (0 left, 1 middle,
+     * 2 right, 3 none/release), bit 5 (32) marks a motion event and bit 6 (64)
+     * marks a wheel event. A trailing `M` is a press/motion while `m` is a
+     * release. So motion with the left button held (a drag) is `b = 32`, whereas
+     * plain hover is `b = 35` (32 | 3).
+     */
+    private handleMouse;
+    private emitKey;
+    private emitPaste;
+    private emitMouse;
+}

package/dist/terminal/renderer.d.ts

@@ -0,0 +1,43 @@
+import type { Buffer } from "./buffer.js";
+export declare class Renderer {
+    private prevSig;
+    private disposed;
+    private prevW;
+    private prevH;
+    private out;
+    /**
+     * The most recent frame, kept so `repaint()` can re-emit it without re-running the
+     * screen's (potentially expensive) render — to heal any drift the terminal
+     * introduced behind our back.
+     */
+    private lastBuf;
+    private blocked;
+    private pendingForce;
+    private drainHandler;
+    init(): void;
+    dispose(): void;
+    /**
+     * @param forceRows rows to repaint unconditionally, even when their contents
+     *   are unchanged. Screens use this for persistent chrome (input box, hints)
+     *   so that terminal-side drift can never leave it stale (see
+     *   `Screen.alwaysRepaintRows`).
+     */
+    render(buf: Buffer, forceRows?: readonly number[]): void;
+    /**
+     * Re-emit the last frame in full. Cheap (no screen re-render) and visually a
+     * no-op when nothing drifted, but it repairs rows the terminal moved on its
+     * own (resize reflow, stray scroll). Called periodically as a safety net.
+     */
+    repaint(): void;
+    /**
+     * Ring the terminal bell.
+     *
+     * Written straight to the stream rather than into a frame: BEL has no visual
+     * effect, so it cannot desync the diffed rows, and it must never end up in
+     * `lastBuf` where repaint() would replay it.
+     */
+    bell(times?: number): void;
+    private draw;
+    private renderRow;
+    private write;
+}

package/dist/terminal/restore.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Escape sequences that undo everything the TUI switches on.
+ *
+ * Mouse tracking is disabled before the alternate screen is left, and the
+ * cursor is restored before the screen swap, so the shell never inherits a
+ * half-configured terminal. Order matters: `?1049l` must come last or the
+ * remaining writes would land on the main screen.
+ */
+export declare const TUI_TEARDOWN: string;
+/** Called once the renderer has entered the alternate screen and raw mode. */
+export declare function markTuiActive(): void;
+/**
+ * Puts the terminal back into a usable state, synchronously and at most once.
+ *
+ * Everything here has to work while the process is dying: no promises, no
+ * asynchronous writes, and every step individually guarded so one failure
+ * cannot skip the rest (a broken `setRawMode` must not leave the cursor
+ * hidden, for example).
+ */
+export declare function restoreTerminalSync(): boolean;
+/** Appends a crash entry to `~/.neutrino/crash.log` and returns the path. */
+export declare function writeCrashLog(kind: string, err: unknown): string | null;
+/**
+ * Installs process-wide handlers that restore the terminal before the process
+ * dies.
+ *
+ * Without this, any throw that escapes a timer, a stream callback or a floating
+ * promise kills the process with raw mode still on and the alternate screen
+ * still active. The visible result is a terminal that works but spews
+ * `[<b>;<x>;<y>M` mouse reports at the shell prompt, because the shell now
+ * receives the mouse events the TUI asked the terminal to send.
+ */
+export interface CrashGuardOptions {
+    /**
+     * Keep SIGHUP for the caller. A detached background service must survive the
+     * terminal that started it closing (on POSIX that arrives as SIGHUP), while
+     * the terminal UI still wants a hangup to end the process.
+     */
+    surviveHangup?: boolean;
+}
+export declare function installCrashGuard(options?: CrashGuardOptions): void;

package/dist/terminal/screen.d.ts

@@ -0,0 +1,57 @@
+import type { Buffer } from "./buffer.js";
+import type { Key, MouseEvent } from "./input.js";
+import type { App } from "../app.js";
+/**
+ * A screen's scrollbar, as seen by the app. Supplying this lets the app turn a
+ * press/drag on the scrollbar column into scrolling, the same way a GUI does.
+ */
+export interface ScrollbarHandle {
+    /** Column the bar is drawn in. */
+    x: number;
+    /** Inclusive row range of the groove. */
+    top: number;
+    bottom: number;
+    /** Total scrollable lines and how many fit on screen. */
+    total: number;
+    viewport: number;
+    /** Current topmost visible line. */
+    offset: number;
+    /** Scroll to the given offset (clamped by the screen). */
+    scrollTo(offset: number): void;
+}
+export declare abstract class Screen {
+    app: App;
+    abstract onKey(key: Key): void;
+    onMouse(_ev: MouseEvent): void;
+    /**
+     * Describe the on-screen scrollbar so the app can drag it, or null when this
+     * screen has none / its content fits. Geometry is only valid right after a
+     * render, which is exactly when the app needs it.
+     */
+    scrollbar(): ScrollbarHandle | null;
+    /**
+     * Rows this screen draws as persistent "chrome" (an input box, key hints, …)
+     * that must be repainted on *every* frame, even when their contents are
+     * unchanged.
+     *
+     * The renderer normally emits only rows whose cells changed, which is what
+     * keeps redraws cheap. But the terminal can shift its own contents behind our
+     * back — ConPTY reflowing the buffer mid-resize, a size-race repaint, a stray
+     * scroll — and a diffed row would then stay stale forever (the classic
+     * "input box swallowed by the log" artefact). Redrawing this small strip by
+     * absolute position every frame makes it self-healing.
+     */
+    alwaysRepaintRows(): number[];
+    /**
+     * Handle a bracketed (or detected) paste. `text` already has its newlines
+     * flattened to spaces, so it can be inserted as a single line. Screens that
+     * have no text input can leave this as a no-op.
+     */
+    onPaste(_text: string): void;
+    abstract render(buf: Buffer): void;
+    /** Whether this screen currently shows a blinking text cursor. Used by the
+     *  app to run (or stop) the cursor blink timer. */
+    showsCursor(): boolean;
+    onActivate(): void;
+    onDeactivate(): void;
+}

package/dist/tray.d.ts

@@ -0,0 +1,14 @@
+export interface TrayOptions {
+    /** Console address opened by a click. */
+    url: string;
+    /** Management endpoint that stops the service. */
+    stopUrl: string;
+    /** Bearer token for `stopUrl`. */
+    token: string;
+    /** Process id the icon belongs to; the icon exits with it. */
+    pid: number;
+}
+/** The icon itself. Only Windows has a notification area, and only it can run this. */
+export declare function startBackgroundTray(options: TrayOptions): {
+    close(): void;
+} | null;