deck-plugin-sdk 0.21.0 → 1.1.0

package/types/core/bridge.d.ts

@@ -42,6 +42,8 @@ export interface Settings {
     closeToTray: boolean;
     startMinimized: boolean;
     reduceMotion: boolean;
+    /** The Servers list (hosts from ~/.ssh/config) under the workspace list. */
+    serversList: boolean;
     soundOnFire: boolean;
     playerPlacement: "fixed" | "floating";
     accent: AccentColor;
@@ -57,12 +59,6 @@ export interface Settings {
     wallpaperDim: number;
     wallpaperBlur: number;
     wallpaperPanel: number;
-    /** Atlassian site host, for building a browse link when a cached ticket has no URL. */
-    jiraSite: string;
-    assistantVoice: string;
-    /** Silence spoken replies without losing the chosen voice. Toggled from the Ask console. */
-    assistantMuted: boolean;
-    userName: string;
     footerItems: Record<FooterItem, boolean>;
     footerOrder: FooterItem[];
     footerVisible: boolean;
@@ -82,18 +78,15 @@ export interface Settings {
     httpMcpRevealSecrets: boolean;
 }
 export declare const DEFAULT_SETTINGS: Settings;
-/** Stop anything being spoken right now. */
-export declare function stopSpeaking(): void;
-export declare function speakWithVoice(text: string, opts?: {
-    rate?: number;
-    onend?: () => void;
-    onerror?: () => void;
-}): SpeechSynthesisUtterance | null;
 export declare const setAutostart: (on: boolean) => Promise<void>;
 export declare const getAutostart: () => Promise<boolean>;
 export declare const toggleFullscreen: () => Promise<boolean>;
 export declare const isFullscreen: () => Promise<boolean>;
-/** Watch these exact paths for external changes; emits "fs-changed" with the path. [] stops. */
+/** Check a sudo password on the server and hold it until Deck exits (never written anywhere). */
+export declare const remoteSudoPassword: (host: string, password: string) => Promise<void>;
+/** Ask for the sudo password of `host` (SudoPasswordPrompt, mounted in App). True once it has
+ *  been accepted, false if the prompt was cancelled. */
+export declare function askSudoPassword(host: string): Promise<boolean>;
 export declare const watchFiles: (paths: string[]) => Promise<void>;
 /** RAM in bytes: Deck and its WebView2 children, plus every claude.exe. */
 export interface MemServer {
@@ -157,12 +150,6 @@ export declare const notesRead: (scope: string, name: string) => Promise<string>
 export declare const notesWrite: (scope: string, name: string, text: string) => Promise<void>;
 export declare const notesDelete: (scope: string, name: string) => Promise<void>;
 export declare const notesRename: (scope: string, from: string, to: string) => Promise<void>;
-export interface SetupCheck {
-    id: string;
-    ok: boolean;
-    detail: string;
-}
-export declare const setupChecks: () => Promise<SetupCheck[]>;
 /** One header, one value. A list rather than a map: order matters, and repeats are legal. */
 export type HttpHeader = [string, string];
 export interface HttpSendRequest {
@@ -190,6 +177,18 @@ export interface HttpSendResult {
  * that does need to cancel should use core/httpclient.ts, which owns that id.
  */
 export declare const httpSend: (req: HttpSendRequest) => Promise<HttpSendResult>;
+/**
+ * The same send under an id the caller chose, so it can be cancelled with `httpCancel` while in
+ * flight. `req` is the full shape http.rs takes; the Requests plugin builds it.
+ */
+export declare const httpSendAs: <T = HttpSendResult>(id: string, req: object) => Promise<T>;
+/** Abort the send started under `id`. A no-op when it has already finished. */
+export declare const httpCancel: (id: string) => Promise<void>;
+/**
+ * Answer an `http-send` event: a send the MCP asked for through sessions.rs, which waits on this
+ * reply under `job`. The Requests plugin listens for the event and does the send.
+ */
+export declare const httpSendReply: (job: string, body: string) => Promise<void>;
 export interface DownloadItem {
     id: string;
     url: string;
@@ -264,40 +263,6 @@ export interface MusicSuggestions {
 export declare const readMusicSuggestions: () => Promise<MusicSuggestions | null>;
 export declare const readMusicTaste: () => Promise<string>;
 export declare const writeMusicTaste: (text: string) => Promise<void>;
-export interface JiraItem {
-    key: string;
-    status: string;
-    title: string;
-    url?: string;
-    /** One sentence on what the ticket asks for — what the rail shows and a drag carries. */
-    summary?: string;
-    /** The full description as markdown, for the detail drawer. */
-    description?: string;
-    assignee?: string;
-    priority?: string;
-}
-export interface TicketCache {
-    tickets: JiraItem[];
-    fetched: number;
-}
-export declare const jiraCached: () => Promise<TicketCache | null>;
-export declare const jiraRefresh: () => Promise<TicketCache | null>;
-export interface CalItem {
-    /** Start as 24-hour HH:MM, or "" for an all-day event. */
-    time: string;
-    end?: string;
-    title: string;
-    /** Video-call join URL, when the event has one. */
-    link?: string;
-    location?: string;
-    attendees?: number;
-}
-export interface CalendarCache {
-    events: CalItem[];
-    fetched: number;
-}
-export declare const calendarCached: () => Promise<CalendarCache | null>;
-export declare const calendarRefresh: () => Promise<CalendarCache | null>;
 /** Start a sign-in. Returns the consent URL to open in the browser. */
 export declare const googleSignIn: () => Promise<string>;
 /** A valid access token, refreshed if needed. Rejects when not connected. */
@@ -310,28 +275,6 @@ export interface GoogleAccount {
 }
 export declare const googleAccount: () => Promise<GoogleAccount | null>;
 export declare const googleSignOut: () => Promise<void>;
-export interface FeedItem {
-    from: string;
-    /** Slack: the channel, or "DM". Mail has none. */
-    where?: string;
-    /** Slack's message body. */
-    text?: string;
-    /** Mail's subject and one-line gloss. */
-    subject?: string;
-    snippet?: string;
-    url?: string;
-    when?: string;
-    /** Slack only: "dm" or "mention". */
-    kind?: string;
-}
-export interface FeedCache {
-    items: FeedItem[];
-    fetched: number;
-}
-export declare const slackCached: () => Promise<FeedCache | null>;
-export declare const slackRefresh: () => Promise<FeedCache | null>;
-export declare const mailCached: () => Promise<FeedCache | null>;
-export declare const mailRefresh: () => Promise<FeedCache | null>;
 export interface UsageBucket {
     tokens: number;
     cost: number;
@@ -374,7 +317,6 @@ export interface AgentSession {
     title: string;
 }
 export declare const sessionList: () => Promise<AgentSession[]>;
-export declare const askAssistant: (message: string, sessionId: string, resume: boolean, userName: string, jiraSite: string) => Promise<string>;
 export interface ScriptJob {
     id: string;
     name: string;
@@ -441,6 +383,18 @@ export declare const fsRead: (path: string) => Promise<string>;
 /** Raw bytes, for a file that is not text — fsRead decodes as UTF-8 and would corrupt it. */
 export declare const fsReadBytes: (path: string) => Promise<Uint8Array<ArrayBuffer>>;
 export declare const fsSize: (path: string) => Promise<number>;
+/** What is at a remote path. A missing one is `exists: false`, not an error. */
+export interface RemoteStat {
+    exists: boolean;
+    dir: boolean;
+    size: number;
+    mtimeMs: number;
+}
+export declare const remoteStat: (path: string) => Promise<RemoteStat>;
+/** The server's home folder as host:/home/user (host+sudo: when it runs as root). */
+export declare const remoteHome: (host: string, sudo: boolean) => Promise<string>;
+/** Host names from ~/.ssh/config, without patterns. */
+export declare const sshHosts: () => Promise<string[]>;
 export declare const fsWrite: (path: string, content: string) => Promise<void>;
 /** Raw bytes — saving a response that is an image or a PDF, which a string would corrupt. */
 export declare const fsWriteBytes: (path: string, bytes: Uint8Array) => Promise<void>;
@@ -465,6 +419,30 @@ export declare const vaultDataRead: (name: string) => Promise<string>;
 export declare const vaultDataWrite: (name: string, text: string) => Promise<void>;
 /** Relaunch Deck — the same binary, so a dev instance stays dev. Used by the plugin toggle. */
 export declare const restartApp: () => Promise<void>;
+/** Fetch the VPS's Script Runner run log over SSH into the local run-log-vps config (vpsjobs.rs). */
+export declare const vpsRunsPull: () => Promise<void>;
+/** What Rust saw of this launch, as Unix ms: process creation and the setup() span. Null until
+ *  setup() has finished, which is before any page script runs. */
+export interface StartupMarks {
+    process: number;
+    setupStart: number;
+    setupEnd: number;
+}
+export declare const startupMarks: () => Promise<StartupMarks | null>;
+/** What a backup file holds: the Deck that wrote it, when, and how many of each thing. */
+export interface BackupSummary {
+    deck: string;
+    created: string;
+    configs: number;
+    plugins: number;
+    languages: number;
+    notes: number;
+}
+/** Every config, plugin and language to one file, credentials left out (backup.rs). */
+export declare const backupExport: (path: string) => Promise<BackupSummary>;
+export declare const backupInspect: (path: string) => Promise<BackupSummary>;
+/** Writes the backup over this machine's copies. Deck should restart afterwards. */
+export declare const backupRestore: (path: string) => Promise<BackupSummary>;
 /** Copy a plugin folder into the plugins directory. Returns its id. Validates before writing. */
 export declare const installPlugin: (src: string) => Promise<string>;
 /** One file of a plugin, as the registry describes it. */

package/types/core/dap.d.ts

@@ -0,0 +1,181 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** How to launch an adapter: a language's `debug.adapter` block, resolved by lsp.rs's rules. */
+export interface AdapterSpec {
+    strategy: string;
+    command?: string;
+    module?: string;
+    args?: string[];
+}
+export interface Transport {
+    start(adapter: AdapterSpec, cwd: string): Promise<string>;
+    /** Another connection to a server adapter: the child session a `startDebugging` asks for. */
+    connect(parent: string): Promise<string>;
+    send(session: string, body: string): void;
+    stop(session: string): void;
+    /** Called once, before the first start: every message and every exit, for every session. */
+    listen(onMessage: (session: string, body: string) => void, onExit: (session: string) => void): Promise<void>;
+}
+export declare const tauriTransport: Transport;
+export interface Frame {
+    id: number;
+    name: string;
+    path?: string;
+    line: number;
+    column: number;
+}
+export interface Variable {
+    name: string;
+    value: string;
+    type?: string;
+    ref: number;
+}
+export interface OutputLine {
+    id: number;
+    category: string;
+    text: string;
+}
+/** A line breakpoint as the editor holds it. `verified` and `line` are the adapter's answer. */
+export interface Breakpoint {
+    line: number;
+    condition?: string;
+    verified?: boolean;
+    message?: string;
+    /** false: switched off, kept in the list and the gutter but not sent to the adapter. */
+    enabled?: boolean;
+}
+export type Status = "starting" | "running" | "paused" | "ended";
+export interface DebugState {
+    /** The session, or null when nothing is being debugged. Ended sessions stay until the next start. */
+    session: null | {
+        /** The connection requests go to: the adapter's, or the newest child session's. */
+        id: string;
+        /**
+         * Every connection of this session, the adapter's first. js-debug answers a launch by asking
+         * for a child session (`startDebugging`) on a second connection, and the program's stops,
+         * stack and variables are all on that one; the first is what ends the whole tree.
+         */
+        conns: string[];
+        name: string;
+        status: Status;
+        /** The thread that stopped, for every request that needs one (Dart isolates are threads). */
+        threadId?: number;
+        /** Why it paused: "breakpoint", "step", "exception", "pause", "entry". */
+        reason?: string;
+        /** The stopped thread's stack, top first. Empty while running. */
+        frames: Frame[];
+        /** The frame being looked at (index into `frames`): the top one on each stop, or a picked one. */
+        frame: number;
+        /** Counts stops, so a view of variables can tell this pause from the last one at the same line. */
+        stops: number;
+        /** The exception filters the adapter offers ("All", "Unhandled" for Dart), from `initialize`. */
+        filters: {
+            filter: string;
+            label: string;
+            default?: boolean;
+        }[];
+        /** The adapter's language ("dart", "python"): exception choices are kept per language. */
+        type: string;
+        /** A launched program ends with the session; an attached one is only detached. */
+        request: "launch" | "attach";
+        /** A stop on an exception: what was thrown, as the adapter describes it. */
+        description?: string;
+        error?: string;
+        /** The language, when the start said (for its debugger's Install button). */
+        languageId?: string;
+        /** The adapter never started or never answered: it is, most likely, not installed. */
+        notInstalled?: boolean;
+    };
+    output: OutputLine[];
+    /** The exception filters switched on, or null for the adapter's defaults. Kept across sessions. */
+    /**
+     * The exception filters switched on, per adapter type, or absent for that adapter's defaults.
+     * Per type because each adapter names its own ("Unhandled" for Dart, "uncaught" for Python).
+     */
+    exceptionFilters: Record<string, string[]>;
+    /** Breakpoints by file path, as the editor set them. */
+    breakpoints: Record<string, Breakpoint[]>;
+}
+/**
+ * The key a file's breakpoints are kept under: backslashes, as Windows tools and the adapter write
+ * paths. Two spellings of one file (slash direction, drive-letter case) must not hold two lists.
+ */
+export declare const bpKey: (path: string) => string;
+/** Whether two paths name the same file (Windows: case-insensitive). */
+export declare const samePath: (a: string, b: string) => boolean;
+/** What a start needs: the adapter, where to run it, and the launch or attach arguments. */
+export interface StartOptions {
+    name: string;
+    adapter: AdapterSpec;
+    cwd: string;
+    request: "launch" | "attach";
+    /** Passed to the adapter as the request's arguments (a launch.json configuration, more or less). */
+    args: Record<string, unknown>;
+    adapterId?: string;
+    /** What to install when the adapter will not start (language.json `debug.install`), in words. */
+    install?: string;
+    /** The language being debugged, so the panel can offer its debugger's Install button. */
+    languageId?: string;
+}
+type Msg = {
+    seq: number;
+    type: string;
+    request_seq?: number;
+    success?: boolean;
+    message?: string;
+    command?: string;
+    event?: string;
+    body?: Record<string, unknown>;
+};
+export declare function createDebugger(transport: Transport): {
+    subscribe: (fn: () => void) => () => void;
+    getState: () => DebugState;
+    start: (o: StartOptions) => Promise<void>;
+    stop: (terminate?: boolean) => Promise<void>;
+    continue: () => Promise<Msg>;
+    next: () => Promise<Msg>;
+    stepIn: () => Promise<Msg>;
+    stepOut: () => Promise<Msg>;
+    pause: () => Promise<Msg>;
+    /** The scopes of a frame (Locals, Globals…), each with the reference its variables are read by. */
+    scopes(frameId: number): Promise<{
+        name: string;
+        ref: number;
+    }[]>;
+    variables: (ref: number) => Promise<Variable[]>;
+    /** Evaluate in a frame: `watch` for the watch list, `repl` for the console, `hover` for the editor. */
+    evaluate(expression: string, frameId?: number, context?: "watch" | "repl" | "hover"): Promise<{
+        value: string;
+        ref: number;
+        error?: undefined;
+    } | {
+        error: string;
+        value?: undefined;
+        ref?: undefined;
+    }>;
+    /** Replace a file's breakpoints, and tell the adapter if a session is running. */
+    setBreakpoints: (path: string, list: Breakpoint[]) => void;
+    /** Add a breakpoint on a line, or remove the one there. */
+    toggleBreakpoint(path: string, line: number): void;
+    /** Set or clear a line's condition, adding the breakpoint if there is none. */
+    setCondition(path: string, line: number, condition: string): void;
+    /** Switch a breakpoint on or off without removing it. */
+    setEnabled(path: string, line: number, on: boolean): void;
+    /**
+     * The breakpoints' lines after an edit moved them. `lines` is in the order of the file's
+     * breakpoints; two that edits brought onto one line become one.
+     */
+    moveBreakpoints(path: string, lines: (number | undefined)[]): void;
+    breakpointsFor: (path: string) => Breakpoint[];
+    /** Look at another frame of the stopped thread's stack (the call stack's click). */
+    selectFrame(i: number): void;
+    clearOutput: () => void;
+    activeFilters: () => string[];
+    /** Choose which exceptions pause the program; remembered, and sent to a running adapter. */
+    setExceptionFilters(filters: string[]): void;
+    /** The debug console's input: echo it, evaluate it in the frame being looked at, print the answer. */
+    repl(expression: string): Promise<void>;
+};
+export type Debugger = ReturnType<typeof createDebugger>;
+/** Deck's debugger. */
+export declare const debug: Debugger;
+export {};

package/types/core/decode.d.ts

@@ -0,0 +1,13 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/**
+ * Text from a file's bytes, by its byte-order mark: UTF-16 when it has one (what `>` writes in
+ * Windows PowerShell 5.1), else UTF-8, else the Windows code page.
+ *
+ * `utf8` is false when the bytes are not UTF-8, so writing the text back (which Deck always does
+ * as UTF-8) would change the file's encoding. A UTF-8 BOM is kept in the text, as `fs_read` and
+ * the git text commands keep it, so the same file reads the same either way.
+ */
+export declare function decodeText(b: Uint8Array): {
+    text: string;
+    utf8: boolean;
+};

package/types/core/icontheme.d.ts

@@ -0,0 +1,28 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { type LucideIcon } from "lucide-react";
+import { type ImportedPack } from "./bridge";
+export type IconRef = {
+    kind: "lucide";
+    icon: LucideIcon;
+} | {
+    kind: "url";
+    name: string;
+} | {
+    kind: "src";
+    src: string;
+};
+export interface IconTheme {
+    id: string;
+    label: string;
+    file(name: string): IconRef;
+    folder(name: string, open: boolean): IconRef;
+}
+export declare const ICON_THEMES: Record<string, IconTheme>;
+export declare function listPacks(): Promise<ImportedPack[]>;
+export declare function loadImportedThemes(): Promise<void>;
+export declare function addPack(pack: ImportedPack): Promise<void>;
+export declare function removePack(id: string): Promise<void>;
+export declare function allThemes(): IconTheme[];
+export declare function themeById(id: string): IconTheme;
+export declare function resolveIconUrl(svgName: string): Promise<string | null>;
+export declare function useIconThemesVersion(): number;

package/types/core/inlay.d.ts

@@ -0,0 +1,37 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** Which hints the editor shows: Settings → Editor → Display. */
+export type InlayShow = "all" | "types" | "parameters" | "off";
+export interface HintPart<U> {
+    label: string;
+    tooltip?: string | {
+        value: string;
+    };
+    location?: {
+        uri: U;
+        range: {
+            startLineNumber: number;
+            startColumn: number;
+            endLineNumber: number;
+            endColumn: number;
+        };
+    };
+}
+export interface Hint<U> {
+    label: string | HintPart<U>[];
+    position: {
+        lineNumber: number;
+        column: number;
+    };
+    kind?: number;
+    paddingLeft?: boolean;
+    paddingRight?: boolean;
+    tooltip?: string | {
+        value: string;
+    };
+}
+/**
+ * Monaco's hints for a `textDocument/inlayHint` reply, keeping only the kinds `show` asks for.
+ * LSP positions are 0-based and Monaco's 1-based. A hint with no kind (a server may send one) is
+ * kept by "all" and dropped by a filter, since it cannot be said to be either.
+ */
+export declare function toInlayHints<U>(reply: any, show: InlayShow, toUri: (uri: string) => U): Hint<U>[];

package/types/core/keys.d.ts

@@ -10,7 +10,7 @@
  * It is also what lets two bindings share a chord honestly — the editor's save and a terminal
  * action can both be Ctrl+S if the two surfaces never have the keyboard at the same time.
  */
-export type Scope = "app" | "workspaces" | "editor" | "http" | "terminal" | "graph" | "graph-visible" | `plugin:${string}`;
+export type Scope = "app" | "workspaces" | "editor" | "terminal" | `plugin:${string}`;
 /** Which thing owns the chord. Absent means a plain window listener. */
 export type Surface = "monaco" | "xterm" | "codemirror";
 export interface KeyBinding {

package/types/core/keystore.d.ts

@@ -38,9 +38,23 @@ export type KeyAction = (() => void) | {
 export declare function onKey(id: string, run: () => void, when?: () => boolean): () => void;
 /** Register several at once — what a module with a dozen chords wants. */
 export declare function onKeys(map: Record<string, KeyAction>): () => void;
-/** Claim a scope. Returns a disposer. */
-export declare function pushScope(scope: Scope): () => void;
+/**
+ * Claim a scope. `holds` says whether the claim counts right now (default: always). Returns a
+ * disposer.
+ */
+export declare function pushScope(scope: Scope, holds?: () => boolean): () => void;
 export declare function activeScopes(): ReadonlySet<Scope>;
+/**
+ * Whether the tool being rendered has the keyboard. A pane provides one that answers "is focus in
+ * me" (see ContentPane in Terminals.tsx); outside any pane a tool owns the window and always has it.
+ *
+ * Without this, a tool's shortcuts were live wherever focus was the moment it mounted, and a
+ * terminal swallows every chord something else has claimed, so an HTTP pane on screen took
+ * Ctrl+Enter away from the shell beside it.
+ */
+export declare const ScopeGate: import("react").Context<() => boolean>;
+/** Claim `scope` for as long as the component is mounted, while its pane (if any) has focus. */
+export declare function useScope(scope: Scope): void;
 /**
  * Run whatever this event is bound to, and say whether anything did.
  *