omp-onlyne 0.0.0-stage → 0.2.0

package/src/types.ts

@@ -0,0 +1,150 @@
+import type { MessageRef, NodeId, ThreadRef, TrustPhase, TrustSeed } from "@onlyne/lib";
+import type { Locale } from "@onlyne/node-host/i18n";
+import type { AcquisitionPolicy } from "./acquire.ts";
+
+/**
+ * Project-scoped configuration in `<project>/.onlyne/config.toml`.
+ *
+ * Delivery decisions are made by OMP's `judge` model role, so no model
+ * endpoint or model name belongs here.
+ */
+export interface OnlyneConfig {
+	path: string;
+	language?: Locale;
+	/** Protocol membership, independent from the node identity. */
+	region: string;
+	node: {
+		id: NodeId;
+		key_ref?: string;
+		/** Where the node identity lives: the project's `.onlyne/keys`, the user's key store, or no key at all. */
+		key_scope?: "project" | "global" | "none";
+	};
+	server: {
+		bind: string;
+		/**
+		 * The port this node answers on. Absent asks the operating system for one, and the
+		 * chosen port is written back here: a node whose address changes on every start
+		 * leaves every peer that recorded it calling a port nobody serves.
+		 */
+		port?: number;
+		/** The externally reachable base URL when a reverse proxy fronts the node. */
+		public_url?: string;
+	};
+	threads: {
+		page_size: number;
+	};
+	/** Bootstrap contact seeds the node reaches at every start. */
+	discovery?: {
+		seeds?: string[];
+	};
+	/** Pinned peer fingerprints; an arriving key that matches is trusted without a prompt. */
+	trust?: TrustSeed[];
+	/** RFC 0018 §2: peers this node may approve without a human confirming first. */
+	acquisition?: AcquisitionPolicy;
+}
+
+/** One execution context the plugin registered for a delivered message. */
+export interface ContextRecord {
+	alias: string;
+	node_id: NodeId;
+	main_agent_id: string;
+	source?: { sender: NodeId; id: string };
+	agent_id?: string;
+	session_file?: string;
+	parent_id?: string;
+	thread_ref?: ThreadRef;
+	summary: string;
+	state: "unbound" | "idle" | "running" | "parked" | "lost";
+	created_at: string;
+	bound_at?: string;
+}
+
+/** One row of the viewer's queue page. */
+export interface QueueItem {
+	id: string;
+	kind: "inbound" | "outbound" | "context" | "decision";
+	label: string;
+	detail: string;
+	at?: string;
+}
+
+/** One message row in the viewer's chat page. */
+export interface ViewerMessage {
+	ref: MessageRef;
+	seq: string;
+	direction: "in" | "out";
+	author: string;
+	at: string;
+	text: string;
+	relation?: string;
+}
+
+/** One thread row in the viewer's chat page. */
+export interface ViewerThread {
+	ref: ThreadRef;
+	alias: string;
+	title: string;
+	state: "open" | "closed";
+	unread: number;
+	last_seq: string;
+	messages: ViewerMessage[];
+	/**
+	 * A thread another node hosts: this node was invited into it, so the viewer can show it and
+	 * cannot offer the writes that belong to its owner.
+	 */
+	read_only?: boolean;
+}
+
+/** One discovery record row the viewer lists as an automatic-discovery candidate. */
+export interface ViewerDiscovery {
+	node_id: NodeId;
+	instance_id: string;
+	base_url: string;
+	source: string;
+	region?: string;
+	membership_state?: "active" | "left";
+	verified_at?: string;
+	expires_at: string;
+	last_seen: string;
+	error?: string;
+}
+
+/** One reachable peer the viewer lists on its contacts page. */
+export interface ViewerContact {
+	node_id: NodeId;
+	instance_id: string;
+	base_url: string;
+	region?: string;
+	last_seen: string;
+}
+
+/** Read-only snapshot the viewer renders. */
+export interface ViewerSnapshot {
+	region?: string;
+	endpoint?: string;
+	queue: QueueItem[];
+	threads: ViewerThread[];
+	contexts: ContextRecord[];
+	discovery: ViewerDiscovery[];
+	contacts: ViewerContact[];
+	discovery_error?: string;
+	/** Every trust row, projected through `trustPhase`: the only stage this package renders. */
+	trust?: Array<{
+		node_id: NodeId;
+		fingerprint: string;
+		phase: TrustPhase;
+		base_url: string;
+	}>;
+	identity?: { public_key: string; fingerprint: string };
+}
+
+/** The one-line runtime status a status widget renders. */
+export interface OnlyneStatus {
+	region: string;
+	node_id: NodeId;
+	nodes: number;
+	neighbors: number;
+	alerts: number;
+	unread: number;
+	discovery_error?: string;
+}

package/src/ui/bootstrap-text.ts

@@ -0,0 +1,125 @@
+import { createTranslator } from "@onlyne/node-host/i18n";
+
+/**
+ * Text of the first-run form, the status row, the mail card and the relative
+ * time phrases: one UI layer, one catalog. Keys are English source text; the
+ * translator reads the process locale on every call, so nothing here is frozen
+ * at import time.
+ */
+const en = {
+	"bootstrap.title": "Onlyne init",
+	"bootstrap.overlayHead": "Onlyne init",
+	"bootstrap.field.region": "Region",
+	"bootstrap.field.nodeId": "Node id",
+	"bootstrap.field.bind": "Server bind",
+	"bootstrap.field.keyScope": "Node key (project/global/none)",
+	"bootstrap.field.pageSize": "Page size",
+	"bootstrap.field.contact": "Node addresses (optional)",
+	"bootstrap.hint.region": "A short name is stored as urn:onlyne:region:<name>",
+	"bootstrap.hint.nodeId": "A short name is stored as urn:onlyne:agent:<name>",
+	"bootstrap.hint.bind": "127.0.0.1",
+	"bootstrap.hint.keyScope":
+		"project: keys in .onlyne/keys (must be git-ignored); global: keys in ~/.config/onlyne/keys; none: loopback development only",
+	"bootstrap.hint.pageSize": "1..100, default 50",
+	"bootstrap.hint.contact":
+		"Nodes discovery cannot reach are contacted by address; stored as discovery.seeds and contacted on every start. Separate addresses with commas",
+	"bootstrap.empty": "[empty]",
+	"bootstrap.regionMissing": "Region is required; a short name is stored as urn:onlyne:region:<name>",
+	"bootstrap.regionPreview": "Will be stored as {uri}",
+	"bootstrap.regionEmpty": "Region must not be empty.",
+	"bootstrap.keyScopeInvalid": "Node key must be project, global or none.",
+	"bootstrap.seedFailed": "Configuration saved and the node started, but {seed} did not connect: {reason}",
+	"bootstrap.started": "Onlyne initialized: {region}",
+	"bootstrap.startFailed": "Configuration written, start failed: {reason}",
+	"bootstrap.notSaved": "Not saved: {reason}",
+	"bootstrap.save": "Save and start",
+	"bootstrap.saving": "Saving…",
+	"bootstrap.cancel": "Cancel",
+	"bootstrap.keys": "Tab/Shift+Tab newline · Enter next field · Ctrl+Enter save · Esc cancel",
+	"bootstrap.header": "{source}. Saving starts this node and publishes discovery.{existing}",
+	"bootstrap.headerExisting": " A project configuration already exists and saving overwrites it.",
+	"status.nodes": "nodes",
+	"status.neighbors": "neighbors",
+	"status.alert": "alert",
+	"status.unread": "unread",
+	"status.discovery": "discovery",
+	"status.unconfigured": "unconfigured",
+	"status.starting": "starting",
+	"mail.supplement": "supplement",
+	"mail.routing": "forwarded",
+	"mail.letter": "letter",
+	"mail.from": "From",
+	"mail.date": "Date",
+	"mail.thread": "Thread",
+	"mail.relation": "Relation",
+	"mail.inReplyTo": "In-Reply-To",
+	"mail.delivery": "Delivery",
+	"mail.status": "Status",
+	"mail.consumed": " · consumed {state}",
+	"mail.rawRecord": "Raw record",
+	"mail.wholeThread": "Whole thread",
+	"time.justNow": "just now",
+	"time.minutesAgo": "{count} min ago",
+	"time.hoursAgo": "{count} h ago",
+	"time.daysAgo": "{count} d ago",
+} as const;
+
+const zh: Record<keyof typeof en, string> = {
+	"bootstrap.title": "Onlyne init",
+	"bootstrap.overlayHead": "Onlyne init",
+	"bootstrap.field.region": "Region",
+	"bootstrap.field.nodeId": "Node id",
+	"bootstrap.field.bind": "Server bind",
+	"bootstrap.field.keyScope": "Node key (project/global/none)",
+	"bootstrap.field.pageSize": "Page size",
+	"bootstrap.field.contact": "节点地址（可选）",
+	"bootstrap.hint.region": "短名保存为 urn:onlyne:region:<短名>",
+	"bootstrap.hint.nodeId": "短名保存为 urn:onlyne:agent:<短名>",
+	"bootstrap.hint.bind": "127.0.0.1",
+	"bootstrap.hint.keyScope":
+		"project：密钥存 .onlyne/keys（git 内需 ignore）；global：存 ~/.config/onlyne/keys；none：回环开发绑定",
+	"bootstrap.hint.pageSize": "1..100，默认 50",
+	"bootstrap.hint.contact": "自动发现到不了的节点按地址联系；保存为 discovery.seeds，每次启动都会联系。多个地址用逗号分隔",
+	"bootstrap.empty": "[空]",
+	"bootstrap.regionMissing": "Region 必填；短名将保存为 urn:onlyne:region:<短名>",
+	"bootstrap.regionPreview": "将保存为 {uri}",
+	"bootstrap.regionEmpty": "Region 不能为空。",
+	"bootstrap.keyScopeInvalid": "Node key 只能是 project、global 或 none。",
+	"bootstrap.seedFailed": "配置已保存并启动，但 {seed} 没连上：{reason}",
+	"bootstrap.started": "Onlyne 已初始化：{region}",
+	"bootstrap.startFailed": "配置已写入，启动失败：{reason}",
+	"bootstrap.notSaved": "未保存：{reason}",
+	"bootstrap.save": "保存并启动",
+	"bootstrap.saving": "保存中…",
+	"bootstrap.cancel": "取消",
+	"bootstrap.keys": "Tab/Shift+Tab 换行 · Enter 下一项 · Ctrl+Enter 保存 · Esc 取消",
+	"bootstrap.header": "{source}。保存后启动本节点并发布发现。{existing}",
+	"bootstrap.headerExisting": "已存在项目配置，保存将覆盖。",
+	"status.nodes": "节点",
+	"status.neighbors": "邻居",
+	"status.alert": "提醒",
+	"status.unread": "未读",
+	"status.discovery": "发现",
+	"status.unconfigured": "未配置",
+	"status.starting": "启动中",
+	"mail.supplement": "补笺",
+	"mail.routing": "转递",
+	"mail.letter": "来信",
+	"mail.from": "发件人",
+	"mail.date": "日期",
+	"mail.thread": "线程",
+	"mail.relation": "关系",
+	"mail.inReplyTo": "回复",
+	"mail.delivery": "投送",
+	"mail.status": "状态",
+	"mail.consumed": " · 已消费 {state}",
+	"mail.rawRecord": "原始记录",
+	"mail.wholeThread": "整段对话",
+	"time.justNow": "刚刚",
+	"time.minutesAgo": "{count} 分钟前",
+	"time.hoursAgo": "{count} 小时前",
+	"time.daysAgo": "{count} 天前",
+};
+
+export const t = createTranslator({ en, "zh-CN": zh });
+export type UiTextKey = keyof typeof en;

package/src/ui/bootstrap.ts

@@ -0,0 +1,363 @@
+import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
+import { getLocale } from "@onlyne/node-host/i18n";
+import {
+	type Component,
+	type DescribeContext,
+	Editor,
+	FormField,
+	type NativeChild,
+	type NativeNode,
+	type NativeUiEvent,
+	Text,
+	type Theme,
+	getEditorTheme,
+	matchesKey,
+	node,
+	span,
+	text as textNode,
+} from "@oh-my-pi/pi-tui";
+import { configPath, normalizeNodeId, normalizeRegion, normalizeServiceUrl, saveConfig, shortNodeId } from "../config.ts";
+import { startRuntime } from "../runtime.ts";
+import type { OnlyneConfig } from "../types.ts";
+import { t, type UiTextKey } from "./bootstrap-text.ts";
+
+const FIELDS = ["region", "nodeId", "bind", "keyScope", "pageSize", "contact"] as const;
+type FieldName = (typeof FIELDS)[number];
+
+const LABELS: Record<FieldName, UiTextKey> = {
+	region: "bootstrap.field.region",
+	nodeId: "bootstrap.field.nodeId",
+	bind: "bootstrap.field.bind",
+	keyScope: "bootstrap.field.keyScope",
+	pageSize: "bootstrap.field.pageSize",
+	contact: "bootstrap.field.contact",
+};
+
+const HINTS: Record<FieldName, UiTextKey> = {
+	region: "bootstrap.hint.region",
+	nodeId: "bootstrap.hint.nodeId",
+	bind: "bootstrap.hint.bind",
+	keyScope: "bootstrap.hint.keyScope",
+	pageSize: "bootstrap.hint.pageSize",
+	contact: "bootstrap.hint.contact",
+};
+
+/** The values the command handler derived from Tern and the saved config. */
+export interface BootstrapDefaults {
+	/** Saved region when re-running, otherwise the Tern session suggestion; empty without Tern. */
+	region: string;
+	regionSource: string;
+	nodeId: string;
+	bind: string;
+	keyScope: string;
+	pageSize: number;
+	/** Existing configuration; the draft carries what the form does not edit. */
+	current?: OnlyneConfig;
+}
+
+type DraftField = { editor: Editor; field: FormField };
+
+/** First-run form. Save writes the project config and starts the node; cancel writes nothing. */
+export class OnlyneBootstrap implements Component {
+	private readonly fields: Record<FieldName, DraftField>;
+	private active: FieldName = "region";
+	private saving = false;
+	private error: string | undefined;
+	private described: NativeNode | undefined;
+	private disposed = false;
+	private locale = getLocale();
+	focused = true;
+	get nativeOverlay() {
+		return {
+			role: "onlyne.bootstrap",
+			size: "lg" as const,
+			anchor: "center" as const,
+			head: t("bootstrap.overlayHead"),
+		};
+	}
+
+	constructor(
+		private readonly pi: ExtensionAPI,
+		private readonly ctx: ExtensionContext,
+		private readonly defaults: BootstrapDefaults,
+		private readonly theme: Theme,
+		private readonly requestRender: () => void,
+		private readonly done: () => void,
+		private readonly signal: AbortSignal,
+	) {
+		this.fields = {
+			region: this.makeField(t(LABELS.region), defaults.region, t(HINTS.region)),
+			nodeId: this.makeField(t(LABELS.nodeId), shortNodeId(defaults.nodeId), t(HINTS.nodeId)),
+			bind: this.makeField(t(LABELS.bind), defaults.bind, t(HINTS.bind)),
+			keyScope: this.makeField(t(LABELS.keyScope), defaults.keyScope, t(HINTS.keyScope)),
+			pageSize: this.makeField(t(LABELS.pageSize), String(defaults.pageSize), t(HINTS.pageSize)),
+			contact: this.makeField(
+				t(LABELS.contact),
+				(defaults.current?.discovery?.seeds ?? []).join(", "),
+				t(HINTS.contact),
+			),
+		};
+	}
+
+	private changed(): void {
+		if (this.disposed || this.signal.aborted) return;
+		this.described = undefined;
+		this.requestRender();
+	}
+
+	private makeField(label: string, value: string, hint: string): DraftField {
+		const editor = new Editor(getEditorTheme());
+		editor.disableSubmit = true;
+		editor.setText(value);
+		editor.setMaxHeight(2);
+		editor.onChange = () => this.changed();
+		const field = new FormField(editor, {
+			label,
+			hint,
+			theme: {
+				label: text => this.theme.bold(text),
+				description: text => this.theme.fg("muted", text),
+				error: text => this.theme.fg("error", text),
+				hint: text => this.theme.fg("muted", text),
+			},
+		});
+		return { editor, field };
+	}
+
+	private value(name: FieldName): string {
+		return this.fields[name].editor.getExpandedText().trim();
+	}
+
+	/** The URI that saving will store; empty input reports the required field instead. */
+	private regionPreview(): string {
+		const raw = this.value("region");
+		return raw.length === 0
+			? t("bootstrap.regionMissing")
+			: t("bootstrap.regionPreview", { uri: normalizeRegion(raw) });
+	}
+
+	private async save(): Promise<void> {
+		if (this.disposed || this.signal.aborted || this.saving) return;
+		const region = this.value("region");
+		const nodeId = this.value("nodeId");
+		const bind = this.value("bind");
+		const keyScope = this.value("keyScope").trim().toLowerCase();
+		if (region.length === 0) {
+			this.fail(t("bootstrap.regionEmpty"));
+			return;
+		}
+		const scope = keyScope === "" ? "project" : keyScope;
+		if (scope !== "project" && scope !== "global" && scope !== "none") {
+			this.fail(t("bootstrap.keyScopeInvalid"));
+			return;
+		}
+		let seeds: string[];
+		try {
+			seeds = this.value("contact")
+				.split(/[,\s]+/)
+				.map(part => part.trim())
+				.filter(part => part.length > 0)
+				.map(normalizeServiceUrl);
+		} catch (error) {
+			this.fail(error instanceof Error ? error.message : String(error));
+			return;
+		}
+		const previous = this.defaults.current;
+		const config: OnlyneConfig = {
+			path: configPath(this.ctx.cwd),
+			region: normalizeRegion(region),
+			node: {
+				id: normalizeNodeId(nodeId),
+				key_scope: scope,
+				// The form does not edit these; saving must not erase them.
+				...(previous?.node.key_ref === undefined ? {} : { key_ref: previous.node.key_ref }),
+			},
+			server: {
+				bind,
+				...(previous?.server.port === undefined ? {} : { port: previous.server.port }),
+				...(previous?.server.public_url === undefined ? {} : { public_url: previous.server.public_url }),
+			},
+			threads: { page_size: Number(this.value("pageSize")) },
+			...(seeds.length === 0 ? {} : { discovery: { seeds } }),
+			...(previous?.trust === undefined ? {} : { trust: previous.trust }),
+			...(previous?.acquisition === undefined ? {} : { acquisition: previous.acquisition }),
+			...(previous?.language === undefined ? {} : { language: previous.language }),
+		};
+		this.saving = true;
+		this.error = undefined;
+		this.changed();
+		let persisted = false;
+		try {
+			await saveConfig(config);
+			persisted = true;
+			const runtime = await startRuntime(this.pi, this.ctx);
+			// The start already read every saved seed; a seed typed just now is read again only
+			// to report its failure in the form the user typed it in.
+			const known = new Set(previous?.discovery?.seeds ?? []);
+			for (const seed of seeds.filter(seed => !known.has(seed))) {
+				try { await runtime.contact(seed); }
+				catch (error) {
+					if (this.signal.aborted) return;
+					this.fail(
+						t("bootstrap.seedFailed", {
+							seed,
+							reason: error instanceof Error ? error.message : String(error),
+						}),
+					);
+					return;
+				}
+			}
+			if (this.disposed || this.signal.aborted) return;
+			this.ctx.ui.notify(t("bootstrap.started", { region: config.region }), "info");
+			this.done();
+		} catch (error) {
+			if (this.signal.aborted) return;
+			const reason = error instanceof Error ? error.message : String(error);
+			this.error = persisted ? t("bootstrap.startFailed", { reason }) : t("bootstrap.notSaved", { reason });
+		} finally {
+			if (!this.disposed && !this.signal.aborted) {
+				this.saving = false;
+				this.changed();
+			}
+		}
+	}
+
+	private fail(message: string): void {
+		this.error = message;
+		this.changed();
+	}
+
+	private fieldRow(name: FieldName): NativeNode {
+		const selected = name === this.active;
+		return node(
+			"row",
+			{
+				role: "omp.btn",
+				actions: { click: `onlyne.bootstrap.field.${name}` },
+				title: t(LABELS[name]),
+				tone: selected ? "accent" : undefined,
+			},
+			[
+				node("text", {
+					spans: [
+						span(t(LABELS[name]), "strong"),
+						span(`: ${this.value(name) || t("bootstrap.empty")}`, "muted"),
+					],
+					wrap: "word",
+				}),
+			],
+			name,
+		);
+	}
+
+	private button(label: string, act: string): NativeNode {
+		return node("row", { role: "omp.btn", actions: { click: act }, title: label }, [textNode(label)], act);
+	}
+
+	describe(_cx: DescribeContext): NativeNode {
+		if (this.locale !== getLocale()) {
+			this.locale = getLocale();
+			this.described = undefined;
+		}
+		if (this.described !== undefined) return this.described;
+		const body: NativeChild[] = [node("text", { text: this.header(), wrap: "word" })];
+		for (const name of FIELDS) {
+			if (name === this.active && !this.saving) {
+				const draft = this.fields[name];
+				draft.field.focused = this.focused;
+				body.push(draft.field);
+			} else body.push(this.fieldRow(name));
+			if (name === "region") body.push(node("text", { text: this.regionPreview(), wrap: "word" }));
+		}
+		if (this.error !== undefined) body.push(node("text", { spans: [span(this.error, "error")], wrap: "word" }));
+		body.push(
+			node("col", { gap: "xs" }, [
+				this.button(this.saving ? t("bootstrap.saving") : t("bootstrap.save"), "onlyne.bootstrap.save"),
+				this.button(t("bootstrap.cancel"), "onlyne.bootstrap.cancel"),
+			]),
+		);
+		body.push(node("text", { text: t("bootstrap.keys"), wrap: "word" }));
+		this.described = node("card", { role: "onlyne.bootstrap" }, body);
+		return this.described;
+	}
+
+	handleNativeEvent(event: NativeUiEvent): void {
+		if (this.disposed || this.signal.aborted || event.type !== "action") return;
+		const act = event.act;
+		if (act === "onlyne.bootstrap.save") {
+			void this.save();
+			return;
+		}
+		if (act === "onlyne.bootstrap.cancel" || act === "onlyne.close") {
+			this.done();
+			return;
+		}
+		if (act.startsWith("onlyne.bootstrap.field.")) {
+			const name = act.slice("onlyne.bootstrap.field.".length) as FieldName;
+			if (FIELDS.includes(name)) {
+				this.active = name;
+				this.changed();
+			}
+		}
+	}
+
+	handleInput(data: string): void {
+		if (this.disposed || this.signal.aborted) return;
+		if (matchesKey(data, "escape")) {
+			this.done();
+			return;
+		}
+		if (matchesKey(data, "ctrl+enter")) {
+			void this.save();
+			return;
+		}
+		if (matchesKey(data, "tab") || matchesKey(data, "shift+tab")) {
+			const step = matchesKey(data, "shift+tab") ? FIELDS.length - 1 : 1;
+			this.active = FIELDS[(FIELDS.indexOf(this.active) + step) % FIELDS.length]!;
+			this.changed();
+			return;
+		}
+		if (matchesKey(data, "enter")) {
+			this.active = FIELDS[(FIELDS.indexOf(this.active) + 1) % FIELDS.length]!;
+			this.changed();
+			return;
+		}
+		this.fields[this.active].editor.handleInput(data);
+		this.changed();
+	}
+
+	render(width: number): readonly string[] {
+		const lines: string[] = [this.theme.bold(t("bootstrap.title")), this.header()];
+		for (const name of FIELDS) {
+			if (name === this.active && !this.saving) {
+				const draft = this.fields[name];
+				draft.field.focused = this.focused;
+				lines.push(...draft.field.render(width));
+			} else {
+				lines.push(
+					`${name === this.active ? ">" : " "} ${t(LABELS[name])}: ${this.value(name) || t("bootstrap.empty")}`,
+				);
+			}
+			if (name === "region") lines.push(this.regionPreview());
+		}
+		if (this.error !== undefined) lines.push(this.theme.fg("error", this.error));
+		lines.push(t("bootstrap.keys"));
+		return new Text(lines.join("\n"), 0, 0).render(width);
+	}
+
+	invalidate(): void {
+		this.described = undefined;
+	}
+
+	private header(): string {
+		const existing = this.defaults.current === undefined ? "" : t("bootstrap.headerExisting");
+		return t("bootstrap.header", { source: this.defaults.regionSource, existing });
+	}
+
+	dispose(): void {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const name of FIELDS) this.fields[name].field.dispose();
+		this.described = undefined;
+	}
+}

package/src/ui/command-text.ts

@@ -0,0 +1,38 @@
+import { createTranslator } from '@onlyne/node-host/i18n';
+const en = {
+  usage: 'Usage: /onlyne or /onlyne menu opens the viewer. /onlyne init creates configuration. /onlyne config edits configuration. /onlyne language en|zh-CN switches language.',
+  init: 'Create project configuration and node keys',
+  config: 'Edit region, node identity, key location and seed addresses',
+  menu: 'Open the Onlyne viewer',
+  language: 'Switch language: en or zh-CN',
+  description: 'Show Onlyne messages, edit configuration or switch language',
+  unavailable: 'The Onlyne viewer and configuration form need an interactive terminal. Run /onlyne init in an interactive terminal.',
+  configured: 'This project is configured. Use /onlyne config to edit it.',
+  savedRegion: 'Region comes from the current configuration',
+  noTern: 'No Tern session was detected. Enter a region',
+  ternRegion: 'Region comes from Tern session "{name}" and can be changed',
+  selected: 'Onlyne language: {language}.',
+  initializing: 'Onlyne is initializing',
+  main: 'Main OMP session',
+  thread: 'Thread from {node}',
+  pending: '{author} · pending consumption',
+};
+const zh: Record<keyof typeof en, string> = {
+  usage: '用法：/onlyne 或 /onlyne menu 打开界面；/onlyne init 创建配置；/onlyne config 修改配置；/onlyne language en|zh-CN 切换语言。',
+  init: '创建项目配置与节点密钥',
+  config: '修改区域、节点身份、密钥位置与种子地址',
+  menu: '打开 Onlyne 界面',
+  language: '切换语言：en 或 zh-CN',
+  description: '查看 Onlyne 消息、修改配置或切换语言',
+  unavailable: 'Onlyne 查看界面和配置面板需要交互式终端。请在交互式终端运行 /onlyne init。',
+  configured: '这个项目已有配置。请用 /onlyne config 修改。',
+  savedRegion: '区域来自当前配置',
+  noTern: '未检测到 Tern 会话，请填写区域',
+  ternRegion: '区域建议值来自 Tern 会话“{name}”，可以修改',
+  selected: 'Onlyne 语言：{language}。',
+  initializing: 'Onlyne 正在初始化',
+  main: 'OMP 主会话',
+  thread: '来自 {node} 的线程',
+  pending: '{author} · 等待消费',
+};
+export const commandText = createTranslator({ en, 'zh-CN': zh });