@north-light/crouter 0.3.154

package/dist/clients/attach/session/reconnect.js

@@ -0,0 +1,127 @@
+// session/reconnect.ts — staying on the broker: the hello handshake, the
+// permanent socket handlers, and the redial supervisor behind them.
+//
+// The viewer's socket is not a one-shot. A resident node that yields EXITS its
+// broker and is revived FRESH by the daemon on the SAME `view.sock` path; an
+// idle-released node's broker is gone until its next wake. Both look identical
+// from here — a `close` — so this module decides whether to hold the pane and
+// keep redialing or to let the viewer die, and it is the ONLY thing that
+// decides that.
+import { reconnectShouldGiveUp } from '../../../core/broker-client/index.js';
+/** A refresh/revive is imminent — redial briskly. */
+const RECONNECT_ACTIVE_DELAY_CAP_MS = 1_000;
+/** Dormant by choice — low-rate patience. */
+const RECONNECT_DORMANT_DELAY_MS = 3_000;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export function createReconnect(ctx, hooks) {
+    const { nodeId, socket, canvasSource } = ctx;
+    let lastSocketError;
+    let reconnecting = false;
+    let viewerDormant = false;
+    // Captured at give-up: a terminal `done` is a CLEAN finalize — the viewer
+    // closes its pane instead of freezing a scary "broker gone" corpse.
+    // `dead`/`canceled` keep the corpse.
+    let finalizedDone = false;
+    // The handshake the viewer sends on connect AND on every successful redial.
+    // After a broker refresh / crash-revive the fresh process has no memory of
+    // this client, so re-`hello` resumes the role chosen at the original attach
+    // and the `welcome` snapshot repaints full scrollback/state. The role is
+    // deliberately fixed for the lifetime of this viewer: local writable attaches
+    // stay writable, while observers stay observers across every redial.
+    const sendHello = () => {
+        socket.send({
+            type: 'hello',
+            role: hooks.role,
+            client_id: hooks.clientId,
+            term: { cols: process.stdout.columns ?? 80, rows: process.stdout.rows ?? 24 },
+        });
+    };
+    // On close we HOLD the pane and keep re-dialing for as long as the canvas
+    // source says the node can come back, giving up ONLY when it is genuinely
+    // terminal (done/dead/canceled or row reaped). There is deliberately NO
+    // wall-clock give-up: a fixed deadline races the daemon's legitimate relaunch
+    // latency (a slow supervision tick on a big canvas, the 20s crash-revive
+    // grace, a slow pi boot), and losing that race dumped the user to a shell
+    // ("broker gone") seconds before the fresh broker bound its socket. A
+    // successful redial re-sends `hello`; the new broker's `welcome` runs
+    // applySnapshot, which resetChat()s the pane and rebuilds from the persisted
+    // .jsonl — a clean "clear + continuation" for free.
+    const attemptReconnect = async () => {
+        reconnecting = true;
+        hooks.setNotice('↻ node refreshing — reconnecting…', { sticky: true });
+        let delay = 200;
+        try {
+            while (!hooks.isTornDown()) {
+                // The row read is advisory: a transient canvas-source error must never
+                // kill the supervisor loop — treat it as "keep trying" and read again
+                // on the next attempt. `canvasSource` is genuinely remote-backed under
+                // `--canvas`, so `getRow` works for both cases — always attempt it.
+                let row;
+                try {
+                    row = await canvasSource.getRow(nodeId);
+                }
+                catch {
+                    row = undefined;
+                }
+                if (row !== undefined && reconnectShouldGiveUp(row)) {
+                    finalizedDone = row?.status === 'done'; // clean finalize vs dead/canceled
+                    break; // genuinely gone → clean close (done) or broker-gone corpse
+                }
+                // A dormant node has NO broker until its next wake. We still track that
+                // (the dormant flag routes a submitted prompt through the wake path
+                // instead of a dead socket), but we DON'T shout about it: a parked pane
+                // is a normal state, not an error. Typing just works — the dormant
+                // submit shows "waking node…" the moment you send — so a persistent
+                // "node dormant" banner is pure noise. Clear the footer when dormant;
+                // keep the reconnecting notice only for a transient broker relaunch.
+                const dormant = row?.status === 'idle' || row?.intent === 'idle-release';
+                const enteredDormancy = dormant && !viewerDormant;
+                viewerDormant = dormant;
+                if (enteredDormancy)
+                    hooks.onEnterDormancy();
+                hooks.setNotice(dormant ? '' : '↻ node refreshing — reconnecting…', { sticky: !dormant });
+                try {
+                    await socket.redial();
+                    sendHello();
+                    viewerDormant = false;
+                    hooks.setNotice('');
+                    return; // reconnected; the welcome snapshot clears + continues the pane
+                }
+                catch {
+                    // ENOENT (socket not recreated yet) / ECONNREFUSED (listen not ready) → retry.
+                    await sleep(dormant ? RECONNECT_DORMANT_DELAY_MS : Math.min(delay, RECONNECT_ACTIVE_DELAY_CAP_MS));
+                    delay *= 2;
+                }
+            }
+        }
+        finally {
+            // However the loop exits — give-up, teardown mid-await, or an unexpected
+            // throw — the supervisor must never stay latched "reconnecting" (a stuck
+            // latch eats every future close event and hangs the viewer forever).
+            reconnecting = false;
+        }
+        if (!hooks.isTornDown())
+            hooks.teardown(finalizedDone ? 'node-done' : 'broker-gone');
+    };
+    const install = () => {
+        socket.on('frame', hooks.onFrame);
+        socket.on('error', (err) => {
+            // Stash the reason; a 'close' follows and teardown converges there, where
+            // a broker-gone message prefers this over the generic text.
+            lastSocketError = err.message;
+        });
+        socket.on('close', () => {
+            if (hooks.isTornDown())
+                return; // a real detach/signal already won
+            if (reconnecting)
+                return; // the dead socket's own close during the redial loop
+            void attemptReconnect();
+        });
+    };
+    return {
+        sendHello,
+        isDormant: () => viewerDormant,
+        lastSocketError: () => lastSocketError,
+        install,
+    };
+}

package/dist/clients/attach/session/state-sync.d.ts

@@ -0,0 +1,38 @@
+import { type SessionState } from '../../../core/session-model/session-state.js';
+import type { BrokerToClient, ClientRole } from '../../../core/runtime/broker-protocol.js';
+/** The repaints a state delta can trigger. Each is a lazy closure so the
+ *  collaborators that answer them may be built after this owner. */
+export interface StateSyncEffects {
+    /** Feed engine state to the input controller — steer-vs-prompt routing reads
+     *  `isStreaming`, so it must stay current. */
+    setEngineState: (engine: NonNullable<SessionState['engine']>) => void;
+    /** The task name lives in the editor's top border; the border color tracks
+     *  the agent's thinking level. Both follow live state. */
+    setEditorTitle: (name: string | undefined) => void;
+    paintEditorFrame: () => void;
+    renderExtensionWidgets: () => void;
+    renderQueued: () => void;
+    renderFooter: () => void;
+    setTerminalTitle: (title: string) => void;
+    /** Panel liveness rides the relayed event stream (agent_start/agent_end/
+     *  queue_update/session_info_changed all move engine state) plus the viewer's
+     *  low-rate poll for changes that emit no event (child status flips). */
+    refreshChrome: () => void;
+}
+export interface SessionStateSync {
+    /** The live folded state. Read it; never hold it across an await. */
+    state: () => SessionState;
+    /** Fold one broker frame through the shared reducer and repaint the slices
+     *  that actually changed. */
+    fold: (frame: BrokerToClient) => void;
+    /** The ONE place this viewer writes session state without a broker frame: an
+     *  idle-released broker has settled its turn and will relay no final event,
+     *  so the viewer must clear the live-only spinner itself. Everything else
+     *  must go through `fold`. */
+    patchLocal: (patch: Partial<NonNullable<SessionState['engine']>>) => void;
+    /** The combined model + thinking-level label a model/thinking change
+     *  announces (e.g. "sonnet medium", "fable x high"). Reads live state, so
+     *  callers fold first, then notice. `off` collapses to the bare model name. */
+    modelThinkingLabel: () => string | undefined;
+}
+export declare function createSessionStateSync(role: ClientRole, fx: StateSyncEffects): SessionStateSync;

package/dist/clients/attach/session/state-sync.js

@@ -0,0 +1,68 @@
+// session/state-sync.ts — the OWNER of this viewer's folded `SessionState`,
+// and the only place that decides what a state change repaints.
+//
+// Everything this viewer knows because the broker told it — role, pi's engine
+// state, context tokens, the queue, the retained display levels — lives in ONE
+// value folded by the shared pure reducer (`core/session-model`), not in a
+// handful of mutable locals patched from a frame switch. The web SPA folds the
+// same reducer, which is what keeps the two viewers from drifting.
+//
+// The dirty tracking IS identity comparison: `reduce` returns the same
+// reference for any frame that changes nothing, and the same sub-object for any
+// slice it leaves alone, so each repaint below is gated on a `!==` against the
+// previous value. No change flags, no repaint-everything.
+import { initialSessionState, reduce } from '../../../core/session-model/session-state.js';
+export function createSessionStateSync(role, fx) {
+    let session = initialSessionState(role);
+    /** Repaint exactly the chrome whose SLICE of session state changed. */
+    const renderDelta = (prev) => {
+        const next = session;
+        if (next === prev)
+            return;
+        const engineChanged = next.engine !== prev.engine;
+        if (engineChanged && next.engine !== undefined) {
+            fx.setEngineState(next.engine);
+            fx.setEditorTitle(next.engine.sessionName);
+        }
+        if (engineChanged)
+            fx.paintEditorFrame();
+        if (next.display.widgets !== prev.display.widgets)
+            fx.renderExtensionWidgets();
+        if (next.display.title !== prev.display.title && next.display.title !== undefined) {
+            fx.setTerminalTitle(next.display.title);
+        }
+        if (next.queued !== prev.queued)
+            fx.renderQueued();
+        if (engineChanged ||
+            next.role !== prev.role ||
+            next.contextTokens !== prev.contextTokens ||
+            next.display.statuses !== prev.display.statuses) {
+            fx.renderFooter();
+        }
+        if (engineChanged)
+            fx.refreshChrome();
+    };
+    return {
+        state: () => session,
+        fold: (frame) => {
+            const prev = session;
+            session = reduce(session, frame);
+            renderDelta(prev);
+        },
+        patchLocal: (patch) => {
+            const engine = session.engine;
+            if (engine === undefined)
+                return;
+            const prev = session;
+            session = { ...session, engine: { ...engine, ...patch } };
+            renderDelta(prev);
+        },
+        modelThinkingLabel: () => {
+            const model = session.engine?.model?.id;
+            if (model === undefined)
+                return undefined;
+            const level = session.engine?.thinkingLevel;
+            return level !== undefined && level !== 'off' ? `${model} ${level}` : model;
+        },
+    };
+}

package/dist/clients/attach/session/teardown.d.ts

@@ -0,0 +1,30 @@
+import type { AttachSession } from './context.js';
+export type TeardownReason = 'detach' | 'broker-gone' | 'signal' | 'node-done';
+export type TeardownSession = Pick<AttachSession, 'nodeId' | 'remote' | 'tui' | 'socket'>;
+export interface TeardownHooks {
+    /** Stop everything this viewer runs locally — timers, the graph overlay, the
+     *  pane tag, the global key listener, the chat view's animations. Runs FIRST,
+     *  before the socket is told anything, so nothing can fire into a dead socket. */
+    stopLocal: () => void;
+    /** The last socket-level error, so a broker-gone teardown can report the
+     *  precise reason (e.g. an oversized-frame overflow) instead of the generic
+     *  message. Read at teardown time, not captured at wiring time. */
+    lastSocketError: () => string | undefined;
+    /** This viewer's tmux pane, as self-tagged at startup. Used only by the
+     *  node-done path to close our own pane. */
+    tagPane: () => string | undefined;
+}
+export interface AttachTeardown {
+    /** Resolves when the session has ended — `runAttach` awaits this. */
+    readonly done: Promise<void>;
+    /** End the session. Idempotent: the first reason wins, later calls no-op. */
+    teardown: (reason: TeardownReason) => void;
+    /** True once teardown has begun. Long-running loops must check this. */
+    isTornDown: () => boolean;
+    /** Register SIGTERM/SIGHUP/SIGINT. Call only AFTER every collaborator
+     *  `stopLocal` touches exists, or a signal races a half-built session.
+     *  (Raw mode swallows ctrl+c as data, so SIGINT is unlikely — handled for
+     *  completeness.) */
+    installSignalHandlers: () => void;
+}
+export declare function createTeardown(s: TeardownSession, hooks: TeardownHooks): AttachTeardown;

package/dist/clients/attach/session/teardown.js

@@ -0,0 +1,96 @@
+// session/teardown.ts — how an attach session ends, exactly once.
+//
+// Four reasons converge here and they are NOT interchangeable:
+//   detach      the user left. Say `bye` so the broker drops this viewer; the
+//               ENGINE RUNS ON (the documented B2 contract). No reaping — see
+//               the note in `teardown` below for why that moved to prune.
+//   broker-gone the socket died and the reconnect supervisor gave up on a node
+//               that is dead/canceled/reaped. Print the precise socket error if
+//               we have one, and leave the pane as a visible corpse.
+//   node-done   the node reached `done` — a CLEAN finalize, not a break. Print
+//               a friendly line and close our OWN pane so the slot clears
+//               instead of stranding a frozen "broker gone" corpse.
+//   signal      a pane kill or daemon teardown.
+//
+// TWO ORDERING RULES the sequence exists to enforce, both easy to break by
+// accident: local activity stops BEFORE the socket does (a timer that fires
+// against a closed socket throws inside a torn-down TUI), and the terminal is
+// restored BEFORE anything is written to stderr (writing through a live
+// alternate-screen frame paints raw bytes over it). `restore` is additionally
+// registered on `process.exit` so a hard exit still un-hides the cursor.
+//
+// This module also owns the `tornDown` latch, which is the session's one
+// "stop doing things" fact — the chrome refresh loop and the identity refresh
+// read it through `isTornDown()` so they cannot outlive the viewer.
+import { closePane, currentTmux, inTmux } from '../../../core/runtime/placement-tmux.js';
+import { FOCUS_REPORTING_OFF } from './focus-events.js';
+export function createTeardown(s, hooks) {
+    const { tui, socket, nodeId, remote } = s;
+    let restored = false;
+    const restore = () => {
+        if (restored)
+            return;
+        restored = true;
+        try {
+            process.stdout.write(FOCUS_REPORTING_OFF);
+            tui.stop();
+        }
+        catch {
+            /* best-effort terminal restore */
+        }
+    };
+    process.once('exit', restore);
+    let tornDown = false;
+    let resolveDone;
+    const done = new Promise((r) => {
+        resolveDone = r;
+    });
+    const teardown = (reason) => {
+        if (tornDown)
+            return;
+        tornDown = true;
+        hooks.stopLocal();
+        // A clean detach tells the broker to drop this viewer (the engine runs on);
+        // on broker-gone the socket is already dead, so skip `bye`.
+        if (reason === 'detach')
+            socket.send({ type: 'bye' });
+        socket.close();
+        restore();
+        // A clean detach leaves the broker running (the engine runs on) — the
+        // documented "detach leaves the broker running" contract (B2). Per-action
+        // reaping of an empty husk used to run here (reapIfEmpty →
+        // teardown/deleteNode, which reaps EVEN a live broker since the user
+        // explicitly detached), but it required a direct canvas.db mutation the
+        // API-only client cannot reach and no per-node reap route exposes, so it is
+        // dropped (B-10). Disposition of an abandoned empty broker: `crtr canvas
+        // prune --empty` (reapEmptyNodes) sweeps it, but only ONCE its pid is dead
+        // — it deliberately spares a LIVE broker as the daemon's domain. So an empty
+        // broker lingers until it idle-releases (or is closed) to a dormant husk,
+        // then prune reaps it. Net vs OLD: a narrow, transient live-empty window
+        // replaces immediate reap — the only faithful option under the API boundary;
+        // a per-node reap route would restore immediate cleanup (future work).
+        if (reason === 'broker-gone') {
+            const msg = hooks.lastSocketError() ??
+                `broker gone — node ${nodeId} is no longer running its engine. Re-focus to reattach.`;
+            process.stderr.write(`\n${msg}\n`);
+        }
+        // Local tmux only — a remote attach has no local pane to close, and a
+        // non-tmux/pipe invocation just prints the line. Pane close is pane-granular
+        // (siblings in a swap-pane window survive); the daemon reconciles the
+        // now-gone viewer row.
+        if (reason === 'node-done') {
+            process.stderr.write(`\n✓ node ${nodeId} finished — final report submitted.\n`);
+            const pane = hooks.tagPane() ?? process.env['TMUX_PANE'] ?? currentTmux()?.pane;
+            if (!remote && pane !== undefined && inTmux())
+                closePane(pane);
+        }
+        resolveDone();
+    };
+    const installSignalHandlers = () => {
+        const onSignal = () => teardown('signal');
+        process.once('SIGTERM', onSignal);
+        process.once('SIGHUP', onSignal);
+        process.once('SIGINT', onSignal);
+    };
+    return { done, teardown, isTornDown: () => tornDown, installSignalHandlers };
+}

package/dist/clients/attach/slash/dispatch.d.ts

@@ -0,0 +1,124 @@
+import type { AutocompleteItem, SlashCommand } from '@earendil-works/pi-tui';
+import type { BrokerSnapshot, ClientRole, ClientToBroker } from '../../../core/runtime/broker-protocol.js';
+/** Everything a slash handler needs: the frame sink, a notice sink, the latest
+ *  engine state (for read-only commands like `/session`), and the cwd (for the
+ *  default `/export` path). */
+export interface SlashContext {
+    /** Send a command frame to the broker (= InputController hooks.onCommand). */
+    send: (frame: ClientToBroker) => void;
+    /** Surface a transient one-line notice in the viewer. */
+    notify: (message: string) => void;
+    /** Latest `welcome`/`session_info_changed` state, if the controller fed it. */
+    state?: BrokerSnapshot['state'];
+    /** cwd for the default `/export` path; defaults to `process.cwd()`. */
+    cwd?: string;
+    /** True for a REMOTE attach (`crtr surface attach --canvas <name>`). The
+     *  native canvas commands that shell a LOCAL `crtr` mutation/read against
+     *  `nodeId` (`/promote`, `/resume-node`, `/context`) are meaningless — or
+     *  worse, id-colliding — for a remote node id, so `dispatchCanvasCommand`
+     *  notifies + no-ops them instead of executing (see `REMOTE_UNSAFE_CANVAS_NAMES`
+     *  below). Defaults to `false` so every existing local caller is unaffected. */
+    remote?: boolean;
+    /** This viewer's FIXED capability, resolved once for the hello handshake
+     *  (`resolveHelloRole`) and never renegotiated. `'observer'` (`--observer`,
+     *  and every remote attach) makes the viewer read-only: the commands that
+     *  drive the engine or mutate the node through the crtr CLI are refused with
+     *  a notice, while the read-only/viewer-local ones stay live. Absent →
+     *  `'controller'`, so every existing writable caller is unaffected. */
+    role?: ClientRole;
+    /** The canvas node this viewer is attached to — used by `/promote` (passed
+     *  as `--node`). Falls back to `CRTR_NODE_ID` when absent; if neither is set
+     *  `/promote` notifies and no-ops. (Unit Q wires this from `runAttach`.) */
+    nodeId?: string;
+    /** The attached node's selected profile. `/resume-node` passes it to canvas
+     *  browse so the resume page opens within this identity. */
+    profileId?: string;
+    /** Toggle the in-process GRAPH overlay (the local subscription-tree view).
+     *  `/graph` is inherently an in-viewer overlay, not a tmux popup, so this unit
+     *  registers `/graph` as a stub that calls this hook. Unit C/Q owns the overlay
+     *  itself and populates this; when absent `/graph` notifies it isn't wired yet. */
+    onGraph?: () => void;
+    /** Detach this viewer (`/quit`). A viewer quit DETACHES — it tears down the
+     *  local TUI/socket and leaves the shared engine running. Wired by viewer.ts to
+     *  `teardown('detach')`; without it `/quit` cannot actually exit (just sending
+     *  `bye` makes the broker drop the socket, which the viewer treats as a dropped
+     *  connection and reconnects). */
+    onQuit?: () => void;
+    /** Copy the last assistant message to the clipboard (`/copy`). Wired by
+     *  viewer.ts (it owns the ChatView that holds the text + the clipboard writer). */
+    onCopy?: () => void;
+    /** OPTIONAL native-picker openers — the InputController fills these from its
+     *  read-op request channel. When absent (channel unwired) the value-picker
+     *  builtins fall back to the text-arg notice. */
+    openModelPicker?: () => void;
+    openSessionPicker?: () => void;
+    openForkPicker?: () => void;
+    openTreePicker?: () => void;
+    openSettingsPicker?: () => void;
+    openScopedModelsPicker?: () => void;
+    /** Open the native /login provider selector. */
+    openLoginPicker?: () => void;
+    /** Open the native /logout provider selector. */
+    openLogoutPicker?: () => void;
+    /** Open the native /mcp server status panel (viewer-local reads of the
+     *  pi-mcp-adapter's config sources + tool cache; connect/auth-start bridge
+     *  to the engine). With a server name, act on that server directly instead
+     *  of opening the picker. Wired by InputController; absent → notice. */
+    openMcpPicker?: (serverName?: string) => void;
+    /** `/color` — recolor the editor's name chip (the "bubble" /rename names).
+     *  `null` clears back to the default chip. Wired by viewer.ts (it owns the
+     *  TitledEditor); absent → only the tmux pane outline is painted. */
+    onColor?: (color: string | null) => void;
+    /** Open the focused node's progressively disclosed metadata dossier. */
+    onNodeMetadata?: () => void;
+}
+/** Canvas slash-commands — implemented NATIVE in the viewer, the ONLY live host:
+ *  the broker binds mode:'rpc', so broker pi-extensions never run their
+ *  interactive (mode==='tui') paths. `/promote` triggers a turn after shelling
+ *  `crtr node promote`; `/resume-node`, `/view`, `/context` each shell a `crtr`
+ *  subcommand via `tmux display-popup` (the viewer runs inside a tmux pane);
+ *  `/graph` toggles the in-process overlay. Exported so the editor folds these
+ *  into the slash autocomplete list. */
+export declare const CANVAS_SLASH_COMMANDS: ReadonlyArray<{
+    name: string;
+    description: string;
+}>;
+/** The same gate, entered from raw editor text: the InputController asks BEFORE
+ *  dispatching so a refused command is reported without reaching command
+ *  dispatch. Unrecognized (extension) commands answer `undefined` here — they
+ *  ride the normal `prompt` path, which the controller's own drive gate covers. */
+export declare function readOnlySlashRefusal(text: string, ctx: SlashContext): string | undefined;
+/** Every leading-command name this viewer consumes ENTIRELY locally — the
+ *  message never reaches the engine as prose, whether dispatched or blocked
+ *  with a notice (a remote-unsafe canvas/builtin command still returns
+ *  `true` from `dispatchSlashCommand` — swallowed with a notice, never
+ *  forwarded as prose — so it counts as consumed here too, independent of
+ *  `remote`). Exactly BUILTIN_NAMES ∪ CANVAS_NAMES ∪ SCOPED_OUT — every name
+ *  `dispatchSlashCommand` returns `true` for (design: inline memory
+ *  references, review Major 6/terminal). Used ONLY for terminal
+ *  ref-decoration suppression (`input/titled-editor.ts`); never merged into
+ *  command completion, which is `slashCommandList` — a different,
+ *  remote-filtered, broker-augmented list. */
+export declare function locallyConsumedCommandNames(): ReadonlySet<string>;
+/** True if `text` is a leading-slash command (vs. a normal prompt). */
+export declare function isSlashCommand(text: string): boolean;
+/**
+ * Parse + dispatch a leading-slash command. Returns `true` if it was handled
+ * (a recognized builtin or a scoped-out notice) — the caller then clears the
+ * editor and sends nothing else. Returns `false` for an UNRECOGNIZED command,
+ * which the caller forwards to the engine as a `prompt` (extension command).
+ */
+export declare function dispatchSlashCommand(text: string, ctx: SlashContext): boolean;
+/** Build slash-command autocomplete entries from the merged command list (the
+ *  broker's `get_commands` result, which T7 may inject) — defaults to the
+ *  vendored builtins. The native canvas commands are always appended (minus the
+ *  remote-unsafe ones when `remote`). Shaped for pi-tui's `CombinedAutocompleteProvider`. */
+export declare function slashCommandList(commands?: ReadonlyArray<{
+    name: string;
+    description?: string;
+}>, remote?: boolean): SlashCommand[];
+/** Same list as flat autocomplete items (value/label/description). */
+export declare function commandAutocompleteItems(commands?: ReadonlyArray<{
+    name: string;
+    description?: string;
+}>, remote?: boolean): AutocompleteItem[];