tabby-clipsnag 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexey Belov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,124 @@
-# Temporary Holding Version
+# tabby-clipsnag
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+English | [Русский](README_ru.md)
+
+A [Tabby](https://tabby.sh) terminal plugin. Press a hotkey, let a noisy command run,
+press it again — the plugin strips the ANSI control garbage and drops clean text on your
+clipboard.
+
+Think of it as "select all the output of the last command", but driven by the actual byte
+stream (colors, cursor moves, TUI redraws and all) instead of the terminal's scrollback,
+and it works the same whether the output scrolled off screen or not.
+
+## Features
+
+- **One toggle hotkey** (default `Ctrl-Shift-X`, `⌘-Shift-X` on macOS) to start and stop.
+- **Passive capture** — installs a `SessionMiddleware` that observes bytes and forwards
+  them unchanged; your terminal renders exactly as before while recording.
+- **Correct ANSI stripping** — the whole capture is decoded and stripped once on stop, so
+  colour codes, cursor movement, OSC titles, and hyperlinks never leak into the clipboard.
+- **Bounded memory** — capture stops growing at a configurable cap (default **5 MB**),
+  keeping the earliest bytes and reporting truncation in the notification.
+- **Auto-stop on idle** — optionally stop by itself after N seconds of silence (default 3 s).
+- **Settings UI** — every option is editable under **Settings → Clipsnag**; nothing to hand-edit.
+- **Leak-safe** — everything is torn down with the tab; closing a recorded tab cancels the
+  recording cleanly with no dangling subscriptions.
+
+## Configuration
+
+Everything is editable in **Settings → Clipsnag** (the hotkey lives under
+**Settings → Hotkeys → Toggle terminal output snagging**). The same values are stored under
+the `clipsnag` key in `~/.config/tabby/config.yaml` (`%APPDATA%\tabby\config.yaml` on Windows)
+and can be hand-edited there, though the settings UI is the recommended way:
+
+```yaml
+hotkeys:
+  clipsnag-toggle: Ctrl-Shift-X
+
+clipsnag:
+  maxCaptureBytes: 5242880        # 5 MB hard cap; older bytes kept, rest discarded
+  autoStopAfterIdleMs: 3000       # stop after 3s of silence; 0 disables auto-stop
+  copyToClipboardOnStop: true     # write the cleaned text to the OS clipboard
+  stopOnTabSwitch: false          # stop + copy as soon as you switch away from the tab
+```
+
+## How it works
+
+```
+hotkey ──▶ ClipsnagService.toggle()
+              │
+              ├─ start: resolve active terminal tab
+              │          └─ TerminalDecorator.startRecording(tab, sink)
+              │                └─ CaptureMiddleware pushed into session.middleware
+              │                     └─ feedFromSession() copies bytes into CaptureBuffer
+              │
+              └─ stop:  CaptureBuffer.finish()
+                           ├─ Buffer.concat + utf8 decode
+                           ├─ stripAnsi(...)
+                           └─ PlatformService.setClipboard({ text })
+```
+
+- `TerminalDecorator` supplies the per-tab lifecycle hook and guarantees cleanup with
+  `subscribeUntilDestroyed`.
+- `SessionMiddleware` is the only supported way to see the raw session byte stream.
+- The service owns the single active recording and subscribes to the toggle hotkey once.
+
+Because bytes are accumulated (not decoded per chunk), multi-byte UTF-8 characters split
+across PTY chunks survive intact, and ANSI sequences that straddle chunk boundaries are
+stripped correctly.
+
+## Building
+
+Requires Node 18+.
+
+```bash
+npm install
+npm run build      # -> dist/index.js (+ .d.ts)
+npm run watch      # incremental rebuild while developing
+npm run typecheck  # tsc --noEmit
+npm run lint       # eslint
+```
+
+## Installing into Tabby for testing
+
+Pick whichever is convenient:
+
+### Option A — point Tabby at the folder (fastest for dev)
+
+```bash
+# Linux / macOS
+tabby --plugin-dir=/absolute/path/to/tabby-clipsnag
+
+# Windows (PowerShell)
+tabby --plugin-dir=C:\Users\you\github\alexoffspace\tabby-clipsnag
+```
+
+`--plugin-dir` must point at the project root (the folder containing `package.json` and
+`dist/`). Run `npm run build` first.
+
+### Option B — drop it into the plugins directory
+
+Copy `package.json` and the whole `dist/` folder into the per-user plugin directory:
+
+```
+Linux:   ~/.config/tabby/plugins/node_modules/tabby-clipsnag/
+macOS:   ~/Library/Application Support/tabby/plugins/node_modules/tabby-clipsnag/
+Windows: %APPDATA%\tabby\plugins\node_modules\tabby-clipsnag\
+```
+
+Then restart Tabby.
+
+### Verifying it loaded
+
+Open **Settings → Plugins** — `tabby-clipsnag` should be listed. Then:
+
+1. Focus a terminal tab and run `ls --color=always`.
+2. Press `Ctrl-Shift-X` — a toast says *recording …*.
+3. Press `Ctrl-Shift-X` again — a second toast reports the size; paste anywhere.
+
+The first press arms capture, the second stops it. With `autoStopAfterIdleMs > 0` you can
+also just wait: recording ends automatically once output goes quiet.
+
+## License
+
+MIT © Alexey Belov — see [LICENSE](LICENSE).

package/README_ru.md

@@ -0,0 +1,129 @@
+# tabby-clipsnag
+
+[English](README.md) | Русский
+
+Плагин для терминала [Tabby](https://tabby.sh). Нажмите горячую клавишу, дайте
+«шумной» команде отработать, нажмите её снова — плагин вырежет ANSI-мусор управления и
+положит в буфер обмена чистый текст.
+
+Это как «выделить весь вывод последней команды», но работающее по реальному потоку
+байтов (цвета, перемещение курсора, перерисовки TUI и всё остальное), а не по скроллбеку
+терминала. Работает одинаково независимо от того, уехал вывод за пределы экрана или нет.
+
+## Возможности
+
+- **Одна горячая клавиша-переключатель** (по умолчанию `Ctrl-Shift-X`, `⌘-Shift-X` на
+  macOS) для запуска и остановки.
+- **Пассивный захват** — устанавливает `SessionMiddleware`, который наблюдает байты и
+  передаёт их дальше без изменений; при записи терминал отображается точно как раньше.
+- **Корректное удаление ANSI** — весь захват декодируется и очищается один раз при
+  остановке, поэтому цветовые коды, движение курсора, OSC-заголовки и гиперссылки никогда
+  не попадут в буфер обмена.
+- **Ограниченная память** — захват перестаёт расти при достижимом лимите (по умолчанию
+  **5 МБ**), сохраняются самые ранние байты, а факт усечения сообщается в уведомлении.
+- **Авто-остановка по простою** — опционально останавливается сам после N секунд тишины
+  (по умолчанию 3 с).
+- **UI настроек** — все параметры редактируются в **Settings → Clipsnag**; править вручную
+  ничего не нужно.
+- **Безопасно относительно утечек** — всё уничтожается вместе с вкладкой; закрытие
+  записываемой вкладки чисто отменяет запись без «висячих» подписок.
+
+## Настройка
+
+Всё редактируется в **Settings → Clipsnag** (а горячая клавиша — в
+**Settings → Hotkeys → Toggle terminal output snagging**). Те же значения хранятся под
+ключом `clipsnag` в `~/.config/tabby/config.yaml` (`%APPDATA%\tabby\config.yaml` на Windows)
+и могут быть отредактированы вручную там же, хотя UI настроек — рекомендуемый способ:
+
+```yaml
+hotkeys:
+  clipsnag-toggle: Ctrl-Shift-X
+
+clipsnag:
+  maxCaptureBytes: 5242880        # жёсткий лимит 5 МБ; старые байты сохраняются, остальное отбрасывается
+  autoStopAfterIdleMs: 3000       # остановка после 3с тишины; 0 отключает авто-остановку
+  copyToClipboardOnStop: true     # записывать очищенный текст в буфер обмена ОС
+  stopOnTabSwitch: false          # остановка и копирование при переключении на другую вкладку
+```
+
+## Как это работает
+
+```
+hotkey ──▶ ClipsnagService.toggle()
+              │
+              ├─ start: resolve active terminal tab
+              │          └─ TerminalDecorator.startRecording(tab, sink)
+              │                └─ CaptureMiddleware pushed into session.middleware
+              │                     └─ feedFromSession() copies bytes into CaptureBuffer
+              │
+              └─ stop:  CaptureBuffer.finish()
+                           ├─ Buffer.concat + utf8 decode
+                           ├─ stripAnsi(...)
+                           └─ PlatformService.setClipboard({ text })
+```
+
+- `TerminalDecorator` предоставляет хук жизненного цикла на вкладку и гарантирует очистку
+  через `subscribeUntilDestroyed`.
+- `SessionMiddleware` — единственный поддерживаемый способ увидеть сырой поток байтов
+  сессии.
+- Сервис владеет единственной активной записью и подписывается на горячую клавишу один раз.
+
+Так как байты накапливаются (а не декодируются по чанкам), многобайтовые символы UTF-8,
+разделённые между чанками PTY, остаются целыми, а ANSI-последовательности, пересекающие
+границы чанков, удаляются корректно.
+
+## Сборка
+
+Требуется Node 18+.
+
+```bash
+npm install
+npm run build      # -> dist/index.js (+ .d.ts)
+npm run watch      # инкрементальная пересборка во время разработки
+npm run typecheck  # tsc --noEmit
+npm run lint       # eslint
+```
+
+## Установка в Tabby для тестирования
+
+Выберите удобный вариант:
+
+### Вариант A — указать Tabby на папку (быстрее всего для разработки)
+
+```bash
+# Linux / macOS
+tabby --plugin-dir=/absolute/path/to/tabby-clipsnag
+
+# Windows (PowerShell)
+tabby --plugin-dir=C:\Users\you\github\alexoffspace\tabby-clipsnag
+```
+
+`--plugin-dir` должен указывать на корень проекта (папку с `package.json` и `dist/`).
+Сначала запустите `npm run build`.
+
+### Вариант B — положить в каталог плагинов
+
+Скопируйте `package.json` и всю папку `dist/` в пользовательский каталог плагинов:
+
+```
+Linux:   ~/.config/tabby/plugins/node_modules/tabby-clipsnag/
+macOS:   ~/Library/Application Support/tabby/plugins/node_modules/tabby-clipsnag/
+Windows: %APPDATA%\tabby\plugins\node_modules\tabby-clipsnag\
+```
+
+Затем перезапустите Tabby.
+
+### Проверка загрузки
+
+Откройте **Settings → Plugins** — там должен быть указан `tabby-clipsnag`. Затем:
+
+1. Сфокусируйте вкладку терминала и запустите `ls --color=always`.
+2. Нажмите `Ctrl-Shift-X` — появится уведомление *recording …*.
+3. Нажмите `Ctrl-Shift-X` снова — второе уведомление сообщит размер; вставьте куда угодно.
+
+Первое нажатие взводит захват, второе — останавливает его. При `autoStopAfterIdleMs > 0`
+можно также просто подождать: запись завершится автоматически, когда вывод затихнет.
+
+## Лицензия
+
+MIT © Алексей Белов — см. [LICENSE](LICENSE).

package/dist/capture-buffer.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * One in-flight recording for a single terminal tab.
+ *
+ * Bytes are accumulated raw (never decoded per chunk) so that multi-byte UTF-8
+ * characters split across chunk boundaries survive. Decoding and ANSI stripping
+ * both happen exactly once, in `finish()`.
+ */
+export declare class CaptureBuffer {
+    private readonly maxBytes;
+    private readonly chunks;
+    private capturedBytes;
+    private truncated;
+    constructor(maxBytes: number);
+    /** Bytes retained so far (always <= maxBytes). */
+    get byteLength(): number;
+    /** True once the cap was hit and later chunks were dropped. */
+    get isTruncated(): boolean;
+    /**
+     * Append a chunk. Chunks past the cap are dropped and the buffer is marked
+     * truncated; we never exceed `maxBytes` of retained memory.
+     */
+    append(data: Buffer): void;
+    /**
+     * Decode, strip ANSI control sequences, and normalise line endings.
+     * Callable once per recording; it does not clear the buffer.
+     */
+    finish(): string;
+    /** Drop all retained data (used when a recording is abandoned). */
+    reset(): void;
+}

package/dist/capture.middleware.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+import { SessionMiddleware } from 'tabby-terminal';
+/**
+ * Passive tap on the session output stream.
+ *
+ * `feedFromSession` receives bytes travelling FROM the session TO the terminal
+ * (i.e. the program's stdout/stderr as rendered). We hand a copy to the sink and
+ * then ALWAYS forward the original bytes — capturing must never alter the stream.
+ *
+ * The middleware is a no-op when `sink` is `null`, so it can safely stay in the
+ * stack across record/stop cycles without re-wiring subscriptions.
+ */
+export declare class CaptureMiddleware extends SessionMiddleware {
+    private sink;
+    /** Begin forwarding copies of session output to `sink`. */
+    start(sink: (data: Buffer) => void): void;
+    /** Stop forwarding (the terminal keeps receiving data normally). */
+    stop(): void;
+    feedFromSession(data: Buffer): void;
+}

package/dist/clipsnag.service.d.ts

@@ -0,0 +1,56 @@
+import { NgZone } from '@angular/core';
+import { AppService, ConfigService, HotkeysService, NotificationsService, PlatformService } from 'tabby-core';
+import { ClipsnagDecorator } from './decorator';
+/**
+ * Coordinates snag recording across tabs.
+ *
+ * At most one recording is active at a time. The service:
+ *  - listens for the toggle hotkey,
+ *  - starts/stops recording on the active terminal tab,
+ *  - auto-stops after a configurable period of output silence,
+ *  - strips ANSI and writes cleaned text to the OS clipboard,
+ *  - reports state changes through Tabby notifications.
+ *
+ * Leak safety: every per-recording RxJS subscription is collected into a single
+ * `Subscription` torn down in `stopRecording()`/`abortRecording()`; the toggle
+ * hotkey subscription lives for the app lifetime, which is correct for a
+ * singleton service. If the recorded tab is destroyed or its session ends,
+ * recording is finalized without touching the dead tab.
+ */
+export declare class ClipsnagService {
+    private readonly config;
+    private readonly hotkeys;
+    private readonly notifications;
+    private readonly platform;
+    private readonly app;
+    private readonly zone;
+    private readonly decorator;
+    private active;
+    constructor(config: ConfigService, hotkeys: HotkeysService, notifications: NotificationsService, platform: PlatformService, app: AppService, zone: NgZone, decorator: ClipsnagDecorator);
+    /** App-lifetime subscription to the toggle hotkey. */
+    private hotkeySubscription;
+    /** Wire up the toggle hotkey. Called once from the plugin module constructor. */
+    init(): void;
+    /** True while a capture is in progress. */
+    get isRecording(): boolean;
+    /** Release app-lifetime resources. Called on plugin/app teardown. */
+    dispose(): void;
+    /** Toggle recording on the currently active terminal tab. */
+    toggle(): Promise<void>;
+    /** Begin capturing the active terminal tab's output. */
+    startRecording(): void;
+    /**
+     * Stop recording, strip ANSI, and copy to the clipboard.
+     * @param automatic true when triggered by the idle timer rather than the hotkey
+     */
+    stopRecording(automatic?: boolean): Promise<void>;
+    /** Finalize a recording because its terminal went away; never touches the tab. */
+    private abortRecording;
+    /**
+     * The active tab may be a plain terminal or a `SplitTabComponent` wrapping
+     * several. In the split case we record the focused pane.
+     */
+    private resolveActiveTerminal;
+    /** Read + validate plugin settings, falling back to defaults per-field. */
+    private settings;
+}

package/dist/config.d.ts

@@ -0,0 +1,39 @@
+import { ConfigProvider } from 'tabby-core';
+/**
+ * Settings shape exposed under `config.store.clipsnag`.
+ * Declared explicitly (rather than left as `any`) so the service reads typed values.
+ */
+export interface ClipsnagConfig {
+    /** Hard cap on captured bytes before truncation kicks in. */
+    maxCaptureBytes: number;
+    /**
+     * Automatically stop recording after this many milliseconds of silence.
+     * `0` disables auto-stop (recording then ends only on a second hotkey press).
+     */
+    autoStopAfterIdleMs: number;
+    /** Copy the cleaned capture to the system clipboard when recording stops. */
+    copyToClipboardOnStop: boolean;
+    /** Stop and copy the capture as soon as the user switches away from the tab. */
+    stopOnTabSwitch: boolean;
+}
+/**
+ * Single source of truth for default settings. Used both by the config provider
+ * (to seed `config.store`) and by the service (as a per-field validation fallback
+ * against malformed user config).
+ */
+export declare const DEFAULT_CLIPSNAG_CONFIG: ClipsnagConfig;
+export declare class ClipsnagConfigProvider extends ConfigProvider {
+    defaults: {
+        hotkeys: {
+            'clipsnag-toggle': string[];
+        };
+        clipsnag: ClipsnagConfig;
+    };
+    platformDefaults: {
+        macOS: {
+            hotkeys: {
+                'clipsnag-toggle': string[];
+            };
+        };
+    };
+}

package/dist/decorator.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { TerminalDecorator, BaseTerminalTabComponent, SessionMiddlewareStack } from 'tabby-terminal';
+import { CaptureMiddleware } from './capture.middleware';
+/**
+ * Per-tab recorder handle.
+ *
+ * Owns the CaptureMiddleware instance that is installed into the tab's current
+ * session stack. `dispose()` is idempotent so it is safe to call from both the
+ * "user stopped recording" and "tab/session vanished" paths.
+ */
+export declare class TabRecorder {
+    private readonly middleware;
+    private readonly stack;
+    private disposed;
+    constructor(middleware: CaptureMiddleware, stack: SessionMiddlewareStack, onData: (data: Buffer) => void);
+    /**
+     * Remove the tap from the session stack. We never call `close()` on the
+     * middleware: it holds Subjects and calling close() would complete them,
+     * making the instance unusable if it were ever reused.
+     */
+    dispose(): void;
+}
+/**
+ * Attaches/detaches per-tab recording support.
+ *
+ * The decorator does two things:
+ *  1. Tracks the tab's *current* session so `startRecording` can find a stack to
+ *     install into, updating it whenever the session is replaced (reconnectable
+ *     sessions emit `sessionChanged$` more than once).
+ *  2. Guarantees cleanup with the tab's lifecycle via `subscribeUntilDestroyed`,
+ *     so no map entry or subscription outlives the tab.
+ */
+export declare class ClipsnagDecorator extends TerminalDecorator {
+    private readonly sessionByTab;
+    attach(terminal: BaseTerminalTabComponent<never>): void;
+    detach(terminal: BaseTerminalTabComponent<never>): void;
+    /**
+     * Start forwarding this tab's output into `onData`.
+     * Returns `null` when the tab has no live session to tap.
+     */
+    startRecording(terminal: BaseTerminalTabComponent<never>, onData: (data: Buffer) => void): TabRecorder | null;
+}

package/dist/hotkeys.d.ts

@@ -0,0 +1,6 @@
+import { HotkeyProvider, HotkeyDescription } from 'tabby-core';
+/** Single toggle hotkey: first press arms capture, the next press stops and copies. */
+export declare const CLIPSNAG_TOGGLE_HOTKEY = "clipsnag-toggle";
+export declare class ClipsnagHotkeyProvider extends HotkeyProvider {
+    provide(): Promise<HotkeyDescription[]>;
+}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { ClipsnagService } from './clipsnag.service';
+export { ClipsnagService } from './clipsnag.service';
+export { ClipsnagDecorator } from './decorator';
+export { ClipsnagConfigProvider, ClipsnagConfig, DEFAULT_CLIPSNAG_CONFIG } from './config';
+export { ClipsnagHotkeyProvider, CLIPSNAG_TOGGLE_HOTKEY } from './hotkeys';
+export { ClipsnagSettingsTabComponent, ClipsnagSettingsTabProvider } from './settings';
+/**
+ * Plugin module.
+ *
+ * Registration points:
+ *  - `HotkeyProvider` (multi) declares the toggle hotkey id so it appears in
+ *    Settings → Hotkeys.
+ *  - `ConfigProvider` (multi) seeds `config.store.hotkeys['clipsnag-toggle']`
+ *    and `config.store.clipsnag`.
+ *  - `TerminalDecorator` (multi) attaches the per-tab recording machinery.
+ *  - `SettingsTabProvider` (multi) adds the "Clipsnag" section to Settings.
+ *
+ * The settings component must be declared here (not just provided) because Tabby
+ * instantiates it through `ComponentFactoryResolver`, which resolves directives
+ * and pipes from the declaring module's scope. `TabbyCoreModule` is imported so
+ * the component can use core building blocks such as `<toggle>`.
+ *
+ * The module constructor runs once at app start; that is where we subscribe the
+ * service to the hotkey stream. `ClipsnagDecorator` is injected by identity so the
+ * service talks to the exact instance Tabby registered.
+ */
+export default class ClipsnagModule {
+    private readonly service;
+    constructor(service: ClipsnagService);
+}

package/dist/index.js

@@ -0,0 +1 @@
+(()=>{"use strict";const t={n:e=>{const s=e&&e.__esModule?()=>e.default:()=>e;return t.d(s,{a:s}),s},d:(e,s)=>{for(var i in s)t.o(s,i)&&!t.o(e,i)&&Object.defineProperty(e,i,{enumerable:!0,get:s[i]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r:t=>{Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})}};let e={};t.r(e),t.d(e,{CLIPSNAG_TOGGLE_HOTKEY:()=>d,ClipsnagConfigProvider:()=>l,ClipsnagDecorator:()=>f,ClipsnagHotkeyProvider:()=>p,ClipsnagService:()=>$,ClipsnagSettingsTabComponent:()=>O,ClipsnagSettingsTabProvider:()=>x,DEFAULT_CLIPSNAG_CONFIG:()=>u,default:()=>j});const s=require("@angular/core"),i=require("@angular/common"),n=require("@angular/forms"),o=require("tabby-core");var r=t.n(o);const a=require("tabby-terminal"),c=require("tabby-settings"),u={maxCaptureBytes:5242880,autoStopAfterIdleMs:3e3,copyToClipboardOnStop:!0,stopOnTabSwitch:!1};class l extends o.ConfigProvider{constructor(){super(...arguments),this.defaults={hotkeys:{"clipsnag-toggle":["Ctrl-Shift-X"]},clipsnag:u},this.platformDefaults={[o.Platform.macOS]:{hotkeys:{"clipsnag-toggle":["⌘-Shift-X"]}}}}}const d="clipsnag-toggle";class p extends o.HotkeyProvider{async provide(){return[{id:d,name:"Toggle terminal output snagging"}]}}class h extends a.SessionMiddleware{constructor(){super(...arguments),this.sink=null}start(t){this.sink=t}stop(){this.sink=null}feedFromSession(t){const e=this.sink;e&&e(t),super.feedFromSession(t)}}class g{constructor(t,e,s){this.middleware=t,this.stack=e,this.disposed=!1,t.start(s),e.push(t)}dispose(){this.disposed||(this.disposed=!0,this.middleware.stop(),this.stack.remove(this.middleware))}}class f extends a.TerminalDecorator{constructor(){super(...arguments),this.sessionByTab=new Map}attach(t){t.session&&this.sessionByTab.set(t,t.session),t.subscribeUntilDestroyed(t.sessionChanged$,e=>{e?this.sessionByTab.set(t,e):this.sessionByTab.delete(t)}),t.subscribeUntilDestroyed(t.destroyed$,()=>{this.sessionByTab.delete(t)})}detach(t){super.detach(t),this.sessionByTab.delete(t)}startRecording(t,e){const s=this.sessionByTab.get(t)??t.session;return s?new g(new h,s.middleware,e):null}}const b=require("rxjs"),y=require("rxjs/operators"),m=String.raw`(?:\u001B\u005C|\u009C)`,v=String.raw`\u0018\u001A\u001B\u0080-\u009F`,S=String.raw`(?:\u001B\]|\u009D)[^\u0007${v}]*(?:\u0007|${m})`,C=String.raw`(?:\u001B[PX^_k]|[\u0090\u0098\u009E\u009F])[^${v}]*${m}`,T=`${String.raw`\u001B\](?:P[\dA-Fa-f]{7}|R)(?:\u0007|${m})?`}|${S}|${C}|${String.raw`(?:\u001B\[|\u009B)[\u0030-\u003F]*[\u0020-\u002F]*[\u0040-\u007E]`}|${String.raw`\u001B(?:[\u0020-\u002F]+[\u0030-\u007E]|[\dA-PR-TZcf-oq-uy=><~|}])`}`,w=function({onlyFirst:t=!1}={}){return new RegExp(T,t?void 0:"g")}();class B{constructor(t){this.maxBytes=t,this.chunks=[],this.capturedBytes=0,this.truncated=!1}get byteLength(){return this.capturedBytes}get isTruncated(){return this.truncated}append(t){if(0===t.length)return;const e=this.maxBytes-this.capturedBytes;if(e<=0)this.truncated=!0;else{if(t.length>e)return this.chunks.push(t.subarray(0,e)),this.capturedBytes+=e,void(this.truncated=!0);this.chunks.push(t),this.capturedBytes+=t.length}}finish(){return function(t){if("string"!=typeof t)throw new TypeError(`Expected a \`string\`, got \`${typeof t}\``);return t.includes("")||t.includes("›")?t.replace(w,""):t}(Buffer.concat(this.chunks,this.capturedBytes).toString("utf8")).replace(/\r\n/g,"\n").replace(/\r/g,"\n")}reset(){this.chunks.length=0,this.capturedBytes=0,this.truncated=!1}}let $=class{constructor(t,e,s,i,n,o,r){this.config=t,this.hotkeys=e,this.notifications=s,this.platform=i,this.app=n,this.zone=o,this.decorator=r,this.active=null,this.hotkeySubscription=null}init(){this.hotkeySubscription||(this.hotkeySubscription=this.hotkeys.hotkey$.subscribe(t=>{t===d&&this.zone.run(()=>{this.toggle()})}))}get isRecording(){return null!==this.active}dispose(){this.abortRecording("plugin shut down"),this.hotkeySubscription?.unsubscribe(),this.hotkeySubscription=null}async toggle(){this.active?await this.stopRecording():this.startRecording()}startRecording(){this.active&&this.abortRecording("a new recording started");const t=this.resolveActiveTerminal();if(!t)return void this.notifications.notice("Clipsnag: no active terminal to record");const e=this.settings(),s=e.maxCaptureBytes,i=new B(s),n=new b.Subject,r=new b.Subscription,a=e.autoStopAfterIdleMs;let c=null;const u=()=>{c?.unsubscribe();const t=(0,b.timer)(a).pipe((0,y.takeUntil)(n)).subscribe(()=>{this.zone.run(()=>{this.stopRecording(!0)})});c=t,r.add(t)},l=this.decorator.startRecording(t,t=>{i.append(t),null!==c&&u()});l?(a>0&&u(),r.add(t.destroyed$.subscribe(()=>{this.zone.run(()=>{this.abortRecording("terminal was closed")})})),r.add(t.sessionChanged$.subscribe(t=>{t||this.zone.run(()=>{this.abortRecording("terminal session ended")})})),e.stopOnTabSwitch&&r.add(this.app.activeTabChange$.subscribe(e=>{(e instanceof o.SplitTabComponent?e.getFocusedTab():e)!==t&&this.zone.run(()=>{this.stopRecording(!0)})})),this.active={terminal:t,buffer:i,recorder:l,idleStop$:n,subscriptions:r},this.notifications.info(`Clipsnag: recording "${t.title}" — press the hotkey again to stop`,`Buffer limit: ${M(s)}`)):this.notifications.notice("Clipsnag: this terminal has no live session yet")}async stopRecording(t=!1){const e=this.active;if(!e)return;this.active=null,e.idleStop$.next(),e.recorder.dispose(),e.subscriptions.unsubscribe();const s=e.buffer.finish(),i=e.buffer.isTruncated,n=e.buffer.byteLength;if(e.buffer.reset(),e.idleStop$.complete(),0===s.length)return void this.notifications.notice("Clipsnag: nothing captured");const o=this.settings();o.copyToClipboardOnStop&&await this.platform.setClipboard({text:s});const r=t?" (idle timeout)":"",a=i?` · truncated at ${M(o.maxCaptureBytes)}`:"",c=o.copyToClipboardOnStop?"copied to clipboard":"captured (clipboard write disabled)";this.notifications.info(`Clipsnag: ${c}${r}`,`${M(n)} of output · ${s.length} characters${a}`)}abortRecording(t){const e=this.active;e&&(this.active=null,e.idleStop$.next(),e.recorder.dispose(),e.subscriptions.unsubscribe(),e.buffer.reset(),e.idleStop$.complete(),this.notifications.notice(`Clipsnag: recording cancelled — ${t}`))}resolveActiveTerminal(){const t=this.app.activeTab;if(!t)return null;if(t instanceof a.BaseTerminalTabComponent)return t;if(t instanceof o.SplitTabComponent){const e=t.getFocusedTab();if(e instanceof a.BaseTerminalTabComponent)return e}return null}settings(){const t=this.config.store.clipsnag,e=Number(t?.maxCaptureBytes),s=Number(t?.autoStopAfterIdleMs);return{maxCaptureBytes:Number.isFinite(e)&&e>0?e:u.maxCaptureBytes,autoStopAfterIdleMs:Number.isFinite(s)&&s>=0?s:u.autoStopAfterIdleMs,copyToClipboardOnStop:t?.copyToClipboardOnStop??u.copyToClipboardOnStop,stopOnTabSwitch:t?.stopOnTabSwitch??u.stopOnTabSwitch}}};function M(t){return t<1024?`${t} B`:t<1048576?`${(t/1024).toFixed(1)} KB`:`${(t/1048576).toFixed(1)} MB`}$=function(t,e,s,i){var n,o=arguments.length,r=o<3?e:null===i?i=Object.getOwnPropertyDescriptor(e,s):i;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)r=Reflect.decorate(t,e,s,i);else for(var a=t.length-1;a>=0;a--)(n=t[a])&&(r=(o<3?n(r):o>3?n(e,s,r):n(e,s))||r);return o>3&&r&&Object.defineProperty(e,s,r),r}([(0,s.Injectable)({providedIn:"root"}),function(t,e){if("object"==typeof Reflect&&"function"==typeof Reflect.metadata)return Reflect.metadata(t,e)}("design:paramtypes",[o.ConfigService,o.HotkeysService,o.NotificationsService,o.PlatformService,o.AppService,s.NgZone,f])],$);const R=1048576;let O=class{constructor(t){this.config=t,this.ensureSettings()}get maxCaptureMiB(){return k((this.settings().maxCaptureBytes??u.maxCaptureBytes)/R,2)}get autoStopSeconds(){return k((this.settings().autoStopAfterIdleMs??u.autoStopAfterIdleMs)/1e3,2)}setMaxCaptureMiB(t){const e=Number(t),s=Number.isFinite(e)&&e>0?Math.round(e*R):u.maxCaptureBytes;this.settings().maxCaptureBytes=s,this.save()}setAutoStopSeconds(t){const e=Number(t),s=Number.isFinite(e)&&e>=0?Math.round(1e3*e):u.autoStopAfterIdleMs;this.settings().autoStopAfterIdleMs=s,this.save()}setCopyToClipboard(t){this.settings().copyToClipboardOnStop=t,this.save()}setStopOnTabSwitch(t){this.settings().stopOnTabSwitch=t,this.save()}ensureSettings(){const t=this.config.store;t.clipsnag&&"object"==typeof t.clipsnag||(t.clipsnag={...u})}settings(){return this.ensureSettings(),this.config.store.clipsnag}save(){this.config.save()}};O=function(t,e,s,i){var n,o=arguments.length,r=o<3?e:null===i?i=Object.getOwnPropertyDescriptor(e,s):i;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)r=Reflect.decorate(t,e,s,i);else for(var a=t.length-1;a>=0;a--)(n=t[a])&&(r=(o<3?n(r):o>3?n(e,s,r):n(e,s))||r);return o>3&&r&&Object.defineProperty(e,s,r),r}([(0,s.Component)({selector:"clipsnag-settings-tab",encapsulation:s.ViewEncapsulation.None,template:'\n        <h3 class="mb-3">Clipsnag</h3>\n\n        <div class="content-box">\n            <div class="form-line">\n                <div class="header">\n                    <div class="title">Capture buffer limit (MiB)</div>\n                    <div class="description">Maximum amount of output kept per recording; older bytes are dropped past this size</div>\n                </div>\n                <input\n                    class="form-control"\n                    type="number"\n                    min="0.1"\n                    step="0.1"\n                    [ngModel]="maxCaptureMiB"\n                    (ngModelChange)="setMaxCaptureMiB($event)"\n                >\n            </div>\n\n            <div class="form-line">\n                <div class="header">\n                    <div class="title">Stop after idle (seconds)</div>\n                    <div class="description">Recording stops automatically after this much silence; set to 0 to disable</div>\n                </div>\n                <input\n                    class="form-control"\n                    type="number"\n                    min="0"\n                    step="1"\n                    [ngModel]="autoStopSeconds"\n                    (ngModelChange)="setAutoStopSeconds($event)"\n                >\n            </div>\n\n            <div class="form-line">\n                <div class="header">\n                    <div class="title">Copy to clipboard on stop</div>\n                    <div class="description">Write the ANSI-stripped capture to the system clipboard when recording ends</div>\n                </div>\n                <toggle [ngModel]="settings().copyToClipboardOnStop" (ngModelChange)="setCopyToClipboard($event)"></toggle>\n            </div>\n\n            <div class="form-line">\n                <div class="header">\n                    <div class="title">Stop on tab switch</div>\n                    <div class="description">Finish and copy the capture as soon as you switch away from the recorded tab</div>\n                </div>\n                <toggle [ngModel]="settings().stopOnTabSwitch" (ngModelChange)="setStopOnTabSwitch($event)"></toggle>\n            </div>\n        </div>\n    '}),function(t,e){if("object"==typeof Reflect&&"function"==typeof Reflect.metadata)return Reflect.metadata(t,e)}("design:paramtypes",[o.ConfigService])],O);class x extends c.SettingsTabProvider{constructor(){super(...arguments),this.id="clipsnag",this.icon="clipboard",this.title="Clipsnag",this.weight=10}getComponentType(){return O}}function k(t,e){const s=10**e;return Math.round(t*s)/s}let P=class{constructor(t){this.service=t,this.service.init()}};P=function(t,e,s,i){var n,o=arguments.length,r=o<3?e:null===i?i=Object.getOwnPropertyDescriptor(e,s):i;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)r=Reflect.decorate(t,e,s,i);else for(var a=t.length-1;a>=0;a--)(n=t[a])&&(r=(o<3?n(r):o>3?n(e,s,r):n(e,s))||r);return o>3&&r&&Object.defineProperty(e,s,r),r}([(0,s.NgModule)({imports:[i.CommonModule,n.FormsModule,r()],declarations:[O],providers:[{provide:o.HotkeyProvider,useClass:p,multi:!0},{provide:o.ConfigProvider,useClass:l,multi:!0},{provide:a.TerminalDecorator,useClass:f,multi:!0},{provide:c.SettingsTabProvider,useClass:x,multi:!0},$,f]}),function(t,e){if("object"==typeof Reflect&&"function"==typeof Reflect.metadata)return Reflect.metadata(t,e)}("design:paramtypes",[$])],P);const j=P;module.exports=e})();

package/dist/settings.d.ts

@@ -0,0 +1,39 @@
+import { ConfigService } from 'tabby-core';
+import { SettingsTabProvider } from 'tabby-settings';
+import { ClipsnagConfig } from './config';
+/**
+ * Settings UI for the Clipsnag plugin.
+ *
+ * Binds two-way to `config.store.clipsnag`; every change persists immediately
+ * through `ConfigService.save()`, mirroring the behaviour of Tabby's own tabs.
+ */
+export declare class ClipsnagSettingsTabComponent {
+    readonly config: ConfigService;
+    constructor(config: ConfigService);
+    /** MiB as shown in the number input. */
+    get maxCaptureMiB(): number;
+    /** Seconds as shown in the number input. */
+    get autoStopSeconds(): number;
+    setMaxCaptureMiB(value: number | string): void;
+    setAutoStopSeconds(value: number | string): void;
+    setCopyToClipboard(value: boolean): void;
+    setStopOnTabSwitch(value: boolean): void;
+    /**
+     * `config.store.clipsnag` is seeded by the config provider, but the settings
+     * component is also reachable before the store is merged (e.g. during a
+     * config-file reload). Materialize the section so nested bindings never read
+     * through `undefined`.
+     */
+    private ensureSettings;
+    /** Config view used by the template; never yields `undefined` fields. */
+    settings(): Partial<ClipsnagConfig>;
+    private save;
+}
+/** Registers the Clipsnag section in Tabby's settings window. */
+export declare class ClipsnagSettingsTabProvider extends SettingsTabProvider {
+    id: string;
+    icon: string;
+    title: string;
+    weight: number;
+    getComponentType(): unknown;
+}

package/package.json

@@ -1,6 +1,65 @@
-{
-  "name": "tabby-clipsnag",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "tabby-clipsnag",
+  "version": "1.0.0",
+  "description": "Tabby plugin: hotkey-driven terminal output capture that strips ANSI and copies clean text to the clipboard",
+  "keywords": [
+    "tabby-plugin",
+    "tabby",
+    "terminus",
+    "clipboard",
+    "ansi",
+    "terminal"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "README_ru.md",
+    "LICENSE"
+  ],
+  "author": "alexoffspace",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alexoffspace/tabby-clipsnag.git"
+  },
+  "scripts": {
+    "build": "webpack --mode production",
+    "watch": "webpack --mode development --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "strip-ansi": "^7.1.0"
+  },
+  "peerDependencies": {
+    "@angular/common": "^15",
+    "@angular/core": "^15",
+    "@angular/forms": "^15",
+    "@angular/platform-browser": "^15",
+    "rxjs": "^7",
+    "tabby-core": "*",
+    "tabby-terminal": "*"
+  },
+  "devDependencies": {
+    "@angular/common": "^15.2.10",
+    "@angular/compiler": "^15.2.10",
+    "@angular/compiler-cli": "^15.2.10",
+    "@angular/core": "^15.2.10",
+    "@angular/platform-browser": "^15.2.10",
+    "@types/node": "^20.14.9",
+    "@typescript-eslint/eslint-plugin": "^7.16.0",
+    "@typescript-eslint/parser": "^7.16.0",
+    "eslint": "^8.57.0",
+    "ts-loader": "^9.5.1",
+    "typescript": "~4.9.5",
+    "webpack": "^5.92.1",
+    "webpack-cli": "^5.1.4"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}