dsh-code 0.1.0

package/lib/index.mjs

@@ -0,0 +1,623 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { createElement, useState, useSyncExternalStore } from "react";
+import { installModelSelection } from "@deepseek-ai/dsh-agent";
+import { assertNever, boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { Box, Text, render, useInput } from "ink";
+import chalk from "chalk";
+//#region src/theme.ts
+/**
+* Terminal color tokens for the dsh TUI, mapped from the product design
+* platform's DeepSeek palette
+* (`packages/client/ui-theme/src/styles/design-platform.css`). Truecolor RGB
+* rides chalk, which degrades automatically on terminals without truecolor.
+*
+* @module @deepseek-ai/dsh-tui/theme
+*/
+/**
+* RGB triples for the TUI, one entry per design-platform token in use.
+* Keep names and values in sync with the CSS custom properties cited inline.
+*/
+const TUI_RGB = {
+	/** Primary brand blue — `--dsw-static-deepseek-500`. */
+	brand: [
+		65,
+		118,
+		230
+	],
+	/** Brighter brand blue for live/streaming emphasis — `--dsw-static-deepseek-400`. */
+	brandBright: [
+		103,
+		158,
+		254
+	],
+	/** Deep brand blue for secondary chrome — `--dsw-static-deepseek-600`. */
+	brandDeep: [
+		72,
+		104,
+		178
+	],
+	/** Muted caption gray — `--dsw-static-neutral-bluish-600`. */
+	dim: [
+		129,
+		133,
+		140
+	],
+	/** Success green — `--dsw-static-green-500`. */
+	success: [
+		34,
+		197,
+		94
+	],
+	/** Error red — `--dsw-static-red-500`. */
+	error: [
+		239,
+		68,
+		68
+	],
+	/** Warning amber — `--dsw-static-amber-500`. */
+	warn: [
+		245,
+		158,
+		11
+	]
+};
+/** Paint with the primary brand blue: whale, wordmark, tool names, accents. */
+function brand(text) {
+	return chalk.rgb(...TUI_RGB.brand)(text);
+}
+/** Paint muted captions, hints, and meta lines. */
+function dim(text) {
+	return chalk.rgb(...TUI_RGB.dim)(text);
+}
+/** Paint failures and error entries. */
+function error(text) {
+	return chalk.rgb(...TUI_RGB.error)(text);
+}
+//#endregion
+//#region src/whale-glyph.ts
+/** Half-block whale glyph rows; render with the brand color. */
+const WHALE_GLYPH = [
+	"    ▄▄▄▄▄▄▄▄█    ▄█▄     ▄",
+	" ▄▄██████████▄▄  ▀███▄████",
+	"▄███████████████▄  ███▀▀▀ ",
+	"██     ▀▀█████▄▀██████    ",
+	"██▄       ▀████▄▄████     ",
+	" ██▄        ▀██████▀      ",
+	"  ▀██▄▄  ██▄  ▀███▄▄      ",
+	"     ▀▀███████▀▀ ▀▀▀      "
+];
+//#endregion
+//#region src/render/status.ts
+/**
+* Compact token count: 517 / 12.2K / 517K / 1.2M (one decimal under three
+* digits), mirroring the web composer's StatsLine format.
+* @param n - token count.
+* @returns display string.
+*/
+function formatTokens(n) {
+	const scaled = (v) => v >= 100 ? String(Math.round(v)) : String(Math.round(v * 10) / 10);
+	if (n < 1e3) return String(n);
+	if (n < 1e6) return `${scaled(n / 1e3)}K`;
+	return `${scaled(n / 1e6)}M`;
+}
+/**
+* Compact duration: 45.2s under a minute, 2m42s from there on.
+* @param ms - duration in milliseconds.
+* @returns display string.
+*/
+function formatDuration(ms) {
+	const s = ms / 1e3;
+	if (s < 60) return `${Math.round(s * 10) / 10}s`;
+	const whole = Math.round(s);
+	return `${Math.floor(whole / 60)}m${whole % 60}s`;
+}
+/**
+* Cache-hit share of billed prompt-side input.
+* @param usage - cumulative token totals.
+* @returns rounded integer percent, or null when no input was billed.
+*/
+function cacheHitPercent(usage) {
+	return usage.inputTokens === 0 ? null : Math.round(usage.cacheReadTokens / usage.inputTokens * 100);
+}
+/**
+* Build the footer's display groups; a group with no data drops out whole.
+* @param facts - identity facts resolved by the runner.
+* @param stats - session figures folded from the durable log.
+* @returns one string per pipe-separated group, in display order.
+*/
+function buildStatusGroups(facts, stats) {
+	const groups = [];
+	const identity = [
+		facts.model,
+		facts.cwd,
+		facts.branch === "" ? void 0 : `⑂ ${facts.branch}`
+	].filter((part) => part !== void 0 && part !== "");
+	if (identity.length > 0) groups.push(identity.join(" · "));
+	if (stats.turns > 0 || stats.steps > 0) {
+		groups.push(`T${stats.turns} · S${stats.steps}`);
+		const durations = [];
+		if (stats.llmMs > 0) durations.push(`llm ${formatDuration(stats.llmMs)}`);
+		if (stats.toolMs > 0) durations.push(`tool ${formatDuration(stats.toolMs)}`);
+		if (durations.length > 0) groups.push(durations.join(" · "));
+	}
+	const cacheHit = cacheHitPercent(stats.usage);
+	if (stats.usage.inputTokens > 0 || stats.usage.outputTokens > 0) {
+		if (cacheHit !== null) groups.push(`cache ${cacheHit}%`);
+		groups.push(`↑${formatTokens(stats.usage.inputTokens)} ↓${formatTokens(stats.usage.outputTokens)}`);
+	}
+	if (facts.sessionId !== "") groups.push(facts.sessionId);
+	return groups;
+}
+//#endregion
+//#region src/app.ts
+/**
+* The Ink terminal app: whale-and-wordmark header in DeepSeek blue, the live
+* transcript, the streaming line, local notices, and the input box. All state
+* arrives through the transcript store (derived from the durable session log)
+* plus local input state; the app owns no session mutation of its own.
+*
+* Element construction uses `createElement` (not JSX): the `dsh` source launch
+* compiles this file through tsx's ESM-only hook, which does not adopt this
+* package's `jsx: react-jsx` compiler option, and the classic JSX runtime
+* would demand a React global.
+*
+* @module @deepseek-ai/dsh-tui/app
+*/
+/** Ink `color` string for one palette triple. */
+function inkColor(triple) {
+	return `rgb(${triple[0]}, ${triple[1]}, ${triple[2]})`;
+}
+/** One settled transcript row. */
+function EntryLine({ entry }) {
+	switch (entry.kind) {
+		case "user": return createElement(Text, null, brand("❯ "), entry.text);
+		case "assistant": return createElement(Text, null, entry.text);
+		case "tool": {
+			const mark = entry.state === "running" ? createElement(Text, { color: inkColor(TUI_RGB.brandBright) }, "◐") : entry.state === "error" ? createElement(Text, { color: inkColor(TUI_RGB.error) }, "⨯") : createElement(Text, { color: inkColor(TUI_RGB.success) }, "⏺");
+			return createElement(Text, null, mark, " ", brand(entry.name), entry.summary === "" ? "" : ` ${dim(entry.summary)}`);
+		}
+		case "error": return createElement(Text, null, error(entry.text));
+		default: return assertNever(entry, "transcript entry kind");
+	}
+}
+/** The whale wordmark header in DeepSeek blue, hugging its content width. */
+function Header() {
+	return createElement(Box, {
+		flexDirection: "row",
+		gap: 1,
+		borderStyle: "round",
+		borderColor: inkColor(TUI_RGB.brand),
+		paddingX: 1,
+		alignSelf: "flex-start"
+	}, createElement(Box, {
+		flexDirection: "column",
+		width: 26
+	}, ...WHALE_GLYPH.map((row, index) => createElement(Text, {
+		key: index,
+		color: inkColor(TUI_RGB.brand)
+	}, row))), createElement(Box, {
+		flexDirection: "column",
+		justifyContent: "center"
+	}, createElement(Text, {
+		color: inkColor(TUI_RGB.brand),
+		bold: true
+	}, "DeepSeek Harness"), createElement(Text, { dimColor: true }, "/help commands · Ctrl+C quit")));
+}
+/**
+* The footer status line: Claude-Code-style identity facts (model, working
+* directory, git branch, session) beside the web composer's session figures
+* (turns/steps, model and tool wall time, cache hit, token totals), joined
+* by brand-colored pipes.
+*/
+function StatusLine({ facts, stats, busy }) {
+	const groups = buildStatusGroups(facts, stats);
+	const children = [busy ? createElement(Text, { color: inkColor(TUI_RGB.brandBright) }, "● ") : createElement(Text, { color: inkColor(TUI_RGB.brand) }, "○ ")];
+	groups.forEach((group, index) => {
+		if (index > 0) children.push(createElement(Text, { dimColor: true }, dim(" | ")));
+		children.push(createElement(Text, { dimColor: true }, group));
+	});
+	return createElement(Box, { paddingX: 1 }, ...children);
+}
+/** The prompt box: slash commands handled locally, other text submitted. */
+function Input({ busy, onSubmit, onQuit }) {
+	const [value, setValue] = useState("");
+	const [notices, setNotices] = useState([]);
+	useInput((input, key) => {
+		if (key.ctrl && (input === "c" || input === "d")) {
+			onQuit();
+			return;
+		}
+		if (key.return) {
+			const text = value.trim();
+			setValue("");
+			if (text === "") return;
+			if (text === "/quit") {
+				onQuit();
+				return;
+			}
+			if (text === "/help") {
+				setNotices([...notices, "/help show commands · /clear clear the screen · /quit exit"]);
+				return;
+			}
+			if (text === "/clear") {
+				setNotices([]);
+				console.clear();
+				return;
+			}
+			if (busy) {
+				setNotices([...notices, "the agent is working — wait for the turn to finish"]);
+				return;
+			}
+			onSubmit(text);
+			return;
+		}
+		if (key.backspace || key.delete) {
+			setValue(value.slice(0, -1));
+			return;
+		}
+		if (input !== "") setValue(value + input);
+	});
+	return createElement(Box, { flexDirection: "column" }, ...notices.map((notice, index) => createElement(Text, {
+		key: index,
+		dimColor: true
+	}, notice)), createElement(Box, null, createElement(Text, { color: inkColor(TUI_RGB.brand) }, busy ? "… " : "❯ "), createElement(Text, null, value)));
+}
+/** The whole terminal app; state arrives via the store, output via Ink. */
+function App({ store, model, cwd, branch, sessionId, onSubmit, onQuit }) {
+	const view = useSyncExternalStore(store.subscribe, store.getView);
+	return createElement(Box, { flexDirection: "column" }, createElement(Header), createElement(Box, {
+		flexDirection: "column",
+		paddingX: 1
+	}, ...view.entries.map((entry, index) => createElement(EntryLine, {
+		key: index,
+		entry
+	})), view.streaming !== "" ? createElement(Text, null, view.streaming) : void 0, view.busy && view.streaming === "" ? createElement(Text, { dimColor: true }, "thinking…") : void 0), createElement(Input, {
+		busy: view.busy,
+		onSubmit,
+		onQuit
+	}), createElement(StatusLine, {
+		facts: {
+			model,
+			cwd,
+			branch,
+			sessionId
+		},
+		stats: view.stats,
+		busy: view.busy
+	}));
+}
+//#endregion
+//#region src/internals.ts
+/**
+* Injectable process-facing effects for the TUI runner. Tests substitute the
+* Ink mount with a capturing fake and the streams with string sinks, keeping
+* the runner's lifecycle testable without a terminal.
+*
+* @module @deepseek-ai/dsh-tui/internals
+*/
+/** Substitutable runner effects; production values write to the real terminal. */
+const internals = {
+	mount: (element) => {
+		const instance = render(element);
+		return { unmount() {
+			instance.unmount();
+		} };
+	},
+	stderr: process.stderr
+};
+//#endregion
+//#region src/render/projection.ts
+/**
+* Pure session-event-to-view projection for the TUI transcript: one reducer
+* over {@link SessionEvent}s producing the ordered entries the renderer draws.
+* Rendering never reads the session directly — this module owns the view
+* model, so tests drive it with plain event arrays.
+*
+* @module @deepseek-ai/dsh-tui/render/projection
+*/
+/** Join the text blocks of a content list; non-text blocks contribute nothing. */
+function textOf(content) {
+	return content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+/** A fresh, empty transcript view. */
+function createTranscriptView() {
+	return {
+		entries: [],
+		streaming: "",
+		todos: [],
+		busy: false,
+		stats: {
+			turns: 0,
+			steps: 0,
+			llmMs: 0,
+			toolMs: 0,
+			usage: {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0
+			}
+		},
+		anchors: {
+			stepStart: /* @__PURE__ */ new Map(),
+			toolStart: /* @__PURE__ */ new Map()
+		}
+	};
+}
+/**
+* Fold one session event into an updated view (copy-on-write).
+* @param view - the view before the event.
+* @param event - one durable session event from `session/event` or the log.
+* @returns the view after the event; the input view is never mutated.
+*/
+function projectEvent(view, event) {
+	switch (event.type) {
+		case "user/message": {
+			const message = event.data;
+			if (message.source.kind === "user") return {
+				...view,
+				entries: [...view.entries, {
+					kind: "user",
+					text: textOf(message.content)
+				}]
+			};
+			const notice = message.source.kind === "plugin" && message.source.form === "notice" ? message.source.summary : message.source.kind;
+			return {
+				...view,
+				entries: [...view.entries, {
+					kind: "user",
+					text: boundContextSummary(notice)
+				}]
+			};
+		}
+		case "assistant/chunk": {
+			const chunk = event.data.chunk;
+			if (chunk.type !== "text-delta") return view;
+			return {
+				...view,
+				streaming: view.streaming + chunk.text
+			};
+		}
+		case "assistant/message": {
+			const key = `${event.data.turn}:${event.data.step}`;
+			const started = view.anchors.stepStart.get(key);
+			view.anchors.stepStart.delete(key);
+			const usage = event.data.usage;
+			const totals = view.stats.usage;
+			return {
+				...view,
+				streaming: "",
+				entries: [...view.entries, {
+					kind: "assistant",
+					text: textOf(event.data.message.content)
+				}],
+				stats: {
+					...view.stats,
+					llmMs: view.stats.llmMs + (started === void 0 ? 0 : Math.max(0, event.time - started)),
+					usage: usage === void 0 ? totals : {
+						inputTokens: totals.inputTokens + usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0),
+						outputTokens: totals.outputTokens + usage.outputTokens,
+						cacheReadTokens: totals.cacheReadTokens + (usage.cacheReadTokens ?? 0)
+					}
+				}
+			};
+		}
+		case "tool/call": {
+			const data = event.data;
+			view.anchors.toolStart.set(data.callId, event.time);
+			return {
+				...view,
+				entries: [...view.entries, {
+					kind: "tool",
+					callId: data.callId,
+					name: data.name,
+					arguments: data.arguments,
+					state: "running",
+					summary: ""
+				}]
+			};
+		}
+		case "tool/result": {
+			const block = event.data.message.content[0];
+			const started = view.anchors.toolStart.get(block.toolCallId);
+			view.anchors.toolStart.delete(block.toolCallId);
+			const summary = boundContextSummary(textOf(block.content));
+			const entries = view.entries.map((entry) => {
+				if (entry.kind !== "tool" || entry.callId !== block.toolCallId) return entry;
+				return {
+					...entry,
+					state: block.isError === true ? "error" : "done",
+					summary
+				};
+			});
+			return {
+				...view,
+				entries,
+				stats: {
+					...view.stats,
+					toolMs: view.stats.toolMs + (started === void 0 ? 0 : Math.max(0, event.time - started))
+				}
+			};
+		}
+		case "todo/write": return {
+			...view,
+			todos: event.data.todos
+		};
+		case "turn/start": return {
+			...view,
+			busy: true,
+			stats: {
+				...view.stats,
+				turns: view.stats.turns + 1
+			}
+		};
+		case "step/start":
+			view.anchors.stepStart.set(`${event.data.turn}:${event.data.step}`, event.time);
+			return {
+				...view,
+				stats: {
+					...view.stats,
+					steps: view.stats.steps + 1
+				}
+			};
+		case "turn/end": {
+			const reason = event.data.reason;
+			if (reason.kind !== "error") return {
+				...view,
+				busy: false
+			};
+			return {
+				...view,
+				busy: false,
+				entries: [...view.entries, {
+					kind: "error",
+					text: `${reason.error.code}: ${reason.error.message}`
+				}]
+			};
+		}
+		default: return view;
+	}
+}
+//#endregion
+//#region src/store.ts
+/**
+* Create one transcript store.
+* @returns the store the runner feeds and the renderer subscribes to.
+*/
+function createTranscriptStore() {
+	let view = createTranscriptView();
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		getView: () => view,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		apply(event) {
+			const next = projectEvent(view, event);
+			if (next === view) return;
+			view = next;
+			for (const listener of listeners) listener();
+		}
+	};
+}
+//#endregion
+//#region src/index.ts
+/**
+* @deepseek-ai/dsh-tui — the interactive terminal driver. The bundle patch
+* rides over dsh-base without Host, HTTP, or browser plugins; this runner
+* creates one Agent through the core registry, mounts the Ink app (DeepSeek
+* blue, whale wordmark), folds submitted prompts into the same durable
+* session, streams `session/event` into the transcript, and on quit flushes
+* and requests process exit.
+*
+* @module @deepseek-ai/dsh-tui
+*/
+/** Stable Cordis plugin name. */
+const name = "tui-runner";
+/** Core services required before the interactive session can start. */
+const inject = [
+	"agentDefaultModel",
+	"agents",
+	"sessions"
+];
+/** Report an unexpected direct-driver failure and request a failing exit. */
+function fail(io, error) {
+	internals.stderr.write(`dsh: ${error instanceof Error ? error.message : String(error)}\n`);
+	io.exit(1);
+}
+/**
+* Resolve the working directory's git branch for the status line.
+* @param cwd - the session's working directory.
+* @returns the branch name, or '' outside a repository or on a detached HEAD.
+*/
+function gitBranch(cwd) {
+	try {
+		return readFileSync(join(cwd, ".git", "HEAD"), "utf8").trim().match(/^ref: refs\/heads\/(.+)$/)?.[1] ?? "";
+	} catch {
+		return "";
+	}
+}
+/**
+* Run the interactive terminal session: create one Agent, mount the app, and
+* keep the process alive until the user quits.
+* @param ctx - plugin context carrying the Agent, default model, Session, and launcher IO services.
+* @param io - process-facing effects.
+*/
+async function run(ctx, io) {
+	await ctx.get("loader")?.await();
+	const agents = ctx.get("agents");
+	const defaultModel = ctx.get("agentDefaultModel");
+	const sessions = ctx.get("sessions");
+	if (agents === void 0 || defaultModel === void 0 || sessions === void 0) return;
+	const selection = defaultModel.currentSelection();
+	const { agent } = await agents.create({
+		sessionId: SessionId(`session-${randomUUID()}`),
+		meta: { cwd: process.cwd() },
+		agentOptions: {
+			provider: selection.provider,
+			model: selection.model
+		},
+		setup: (agentCtx) => {
+			installModelSelection(agentCtx, {
+				current: selection,
+				assembled: void 0
+			});
+		}
+	});
+	const store = createTranscriptStore();
+	const off = ctx.on("session/event", (session, event) => {
+		if (session.id === agent.session.id) store.apply(event);
+	});
+	const mountRef = {};
+	let quitting = false;
+	const quit = () => {
+		if (quitting) return;
+		quitting = true;
+		off();
+		mountRef.current?.unmount();
+		sessions.flush(agent.session).catch((flushError) => {
+			internals.stderr.write(`dsh: session flush failed: ${flushError instanceof Error ? flushError.message : String(flushError)}\n`);
+		}).then(() => {
+			io.exit(0);
+		});
+	};
+	mountRef.current = io.mount(createElement(App, {
+		store,
+		model: `${selection.provider}/${selection.model}`,
+		cwd: basename(process.cwd()),
+		branch: gitBranch(process.cwd()),
+		sessionId: agent.session.id.slice(-8),
+		onSubmit: (text) => {
+			agent.followup(createUserMessage({
+				content: [{
+					type: "text",
+					text
+				}],
+				source: { kind: "user" }
+			}));
+		},
+		onQuit: quit
+	}));
+}
+/**
+* Mount the interactive terminal driver.
+* @param ctx - plugin context carrying core services and the launcher-provided exit request.
+*/
+function apply(ctx) {
+	const exit = ctx.get("appExit");
+	if (exit === void 0) throw new Error("tui-runner: the launcher must provide ctx.appExit before the tree mounts");
+	const io = {
+		mount: internals.mount,
+		exit
+	};
+	run(ctx, io).catch((error) => {
+		fail(io, error);
+	});
+}
+//#endregion
+export { apply, inject, name };

package/lib/invariant.mjs

@@ -0,0 +1,21 @@
+//#region src/invariant.ts
+const PACKAGE_NAME = "@deepseek-ai/dsh-tui";
+/** Cordis companion plugin name. */
+const name = "tui-invariant";
+/** Service required before the companion can register. */
+const inject = ["invariants"];
+/**
+* No runtime invariant beyond the projection's own contract: the TUI renders
+* only from `session/event` (model-visible means logged), so the display
+* relation the renderer could desync from is already asserted by the session
+* log's projection invariants; this companion registers nothing.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/app.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The Ink terminal app: whale-and-wordmark header in DeepSeek blue, the live
+ * transcript, the streaming line, local notices, and the input box. All state
+ * arrives through the transcript store (derived from the durable session log)
+ * plus local input state; the app owns no session mutation of its own.
+ *
+ * Element construction uses `createElement` (not JSX): the `dsh` source launch
+ * compiles this file through tsx's ESM-only hook, which does not adopt this
+ * package's `jsx: react-jsx` compiler option, and the classic JSX runtime
+ * would demand a React global.
+ *
+ * @module @deepseek-ai/dsh-tui/app
+ */
+import { type ReactElement } from 'react';
+import type { TranscriptStore } from './store.ts';
+/** Props the runner hands the app; callbacks stay owned by the runner. */
+export interface AppProps {
+    /** Event-fed transcript store for the live session. */
+    store: TranscriptStore;
+    /** `provider/model` selection serving this session. */
+    model: string;
+    /** Working-directory basename the session serves. */
+    cwd: string;
+    /** Git branch name, empty outside a repository. */
+    branch: string;
+    /** Short session identifier. */
+    sessionId: string;
+    /** Submit one human prompt; the runner folds it into the session. */
+    onSubmit(text: string): void;
+    /** Quit: unmount, flush, and request process exit. */
+    onQuit(): void;
+}
+/** The whole terminal app; state arrives via the store, output via Ink. */
+export declare function App({ store, model, cwd, branch, sessionId, onSubmit, onQuit }: AppProps): ReactElement;

package/lib/types/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @deepseek-ai/dsh-tui — the interactive terminal driver. The bundle patch
+ * rides over dsh-base without Host, HTTP, or browser plugins; this runner
+ * creates one Agent through the core registry, mounts the Ink app (DeepSeek
+ * blue, whale wordmark), folds submitted prompts into the same durable
+ * session, streams `session/event` into the transcript, and on quit flushes
+ * and requests process exit.
+ *
+ * @module @deepseek-ai/dsh-tui
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Stable Cordis plugin name. */
+export declare const name = "tui-runner";
+/** Core services required before the interactive session can start. */
+export declare const inject: string[];
+/**
+ * Mount the interactive terminal driver.
+ * @param ctx - plugin context carrying core services and the launcher-provided exit request.
+ */
+export declare function apply(ctx: Context): void;