fengming 0.3.8 → 0.3.9

package/dist/outbound.types-DVkbsxo8.d.ts

@@ -0,0 +1,291 @@
+import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { S as MarkdownTableMode, T as ReplyToMode } from "./types.base-BqSq2llv.js";
+import { s as ReplyPayload } from "./types-CrmoEuWv.js";
+import { c as MessagePresentation, x as ReplyPayloadDeliveryPin } from "./payload-BoZF5rJz.js";
+import { t as ChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { t as OutboundSendDeps } from "./send-deps-BaEC80iY.js";
+import { t as OutboundMediaAccess } from "./load-options-CTuppEe4.js";
+import { P as MessageReceipt } from "./types-C4HgagiY.js";
+import { A as ChannelPollResult, O as ChannelOutboundTargetMode, k as ChannelPollContext } from "./types.core-BIOUPd66.js";
+
+//#region src/infra/outbound/deliver-types.d.ts
+type OutboundDeliveryResult = {
+  channel: Exclude<ChannelId, "none">;
+  messageId: string;
+  chatId?: string;
+  channelId?: string;
+  roomId?: string;
+  conversationId?: string;
+  timestamp?: number;
+  toJid?: string;
+  pollId?: string;
+  receipt?: MessageReceipt;
+  meta?: Record<string, unknown>;
+};
+type OutboundPayloadDeliverySuppressionReason = "cancelled_by_message_sending_hook" | "cancelled_by_reply_payload_sending_hook" | "empty_after_message_sending_hook" | "empty_after_reply_payload_sending_hook" | "no_visible_payload" | "adapter_returned_no_identity";
+type OutboundDeliveryFailureStage = "platform_send" | "queue" | "unknown";
+type OutboundPayloadDeliveryOutcome = {
+  index: number;
+  status: "sent";
+  results: OutboundDeliveryResult[];
+} | {
+  index: number;
+  status: "suppressed";
+  reason: OutboundPayloadDeliverySuppressionReason;
+  hookEffect?: {
+    cancelReason?: string;
+    metadata?: Record<string, unknown>;
+  };
+} | {
+  index: number;
+  status: "failed";
+  error: unknown;
+  sentBeforeError: boolean;
+  stage: OutboundDeliveryFailureStage;
+};
+//#endregion
+//#region src/auto-reply/chunk.d.ts
+type TextChunkProvider = ChannelId;
+/**
+ * Chunking mode for outbound messages:
+ * - "length": Split only when exceeding textChunkLimit (default)
+ * - "newline": Prefer breaking on "soft" boundaries. Historically this split on every
+ *   newline; now it only breaks on paragraph boundaries (blank lines) unless the text
+ *   exceeds the length limit.
+ */
+type ChunkMode = "length" | "newline";
+declare function resolveTextChunkLimit(cfg: FengMingConfig | undefined, provider?: TextChunkProvider, accountId?: string | null, opts?: {
+  fallbackLimit?: number;
+}): number;
+declare function resolveChunkMode(cfg: FengMingConfig | undefined, provider?: TextChunkProvider, accountId?: string | null): ChunkMode;
+/**
+ * Split text on newlines, trimming line whitespace.
+ * Blank lines are folded into the next non-empty line as leading "\n" prefixes.
+ * Long lines can be split by length (default) or kept intact via splitLongLines:false.
+ */
+declare function chunkByNewline(text: string, maxLineLength: number, opts?: {
+  splitLongLines?: boolean;
+  trimLines?: boolean;
+  isSafeBreak?: (index: number) => boolean;
+}): string[];
+/**
+ * Unified chunking function that dispatches based on mode.
+ */
+declare function chunkTextWithMode(text: string, limit: number, mode: ChunkMode): string[];
+declare function chunkMarkdownTextWithMode(text: string, limit: number, mode: ChunkMode): string[];
+declare function chunkText(text: string, limit: number): string[];
+declare function chunkMarkdownText(text: string, limit: number): string[];
+//#endregion
+//#region src/infra/outbound/formatting.d.ts
+type OutboundDeliveryFormattingOptions = {
+  textLimit?: number;
+  maxLinesPerMessage?: number;
+  tableMode?: MarkdownTableMode;
+  chunkMode?: ChunkMode;
+  parseMode?: "HTML";
+};
+//#endregion
+//#region src/infra/outbound/identity-types.d.ts
+type OutboundIdentity = {
+  name?: string;
+  avatarUrl?: string;
+  emoji?: string;
+  theme?: string;
+};
+//#endregion
+//#region src/channels/plugins/outbound.types.d.ts
+type ChannelOutboundContext = {
+  cfg: FengMingConfig;
+  to: string;
+  text: string;
+  mediaUrl?: string;
+  audioAsVoice?: boolean;
+  mediaAccess?: OutboundMediaAccess;
+  mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  gifPlayback?: boolean; /** Send image, GIF, or video as document to avoid channel compression. */
+  forceDocument?: boolean;
+  replyToId?: string | null;
+  replyToIdSource?: "explicit" | "implicit";
+  replyToMode?: ReplyToMode;
+  formatting?: OutboundDeliveryFormattingOptions;
+  threadId?: string | number | null;
+  accountId?: string | null;
+  identity?: OutboundIdentity;
+  deps?: OutboundSendDeps;
+  silent?: boolean;
+  gatewayClientScopes?: readonly string[];
+};
+type ChannelOutboundPayloadContext = ChannelOutboundContext & {
+  payload: ReplyPayload;
+};
+type ChannelPresentationCapabilities = {
+  /** Whether the channel accepts structured presentation payloads at all. */supported?: boolean; /** Whether the channel can render button action blocks natively. */
+  buttons?: boolean; /** Whether the channel can render select/menu blocks natively. */
+  selects?: boolean; /** Whether the channel can render low-emphasis context blocks natively. */
+  context?: boolean; /** Whether the channel can render divider blocks natively. */
+  divider?: boolean; /** Per-channel limits used to adapt portable presentation blocks before rendering. */
+  limits?: {
+    actions?: {
+      /** Maximum total button/select actions in one message. */maxActions?: number; /** Maximum buttons per rendered action row. */
+      maxActionsPerRow?: number; /** Maximum action rows in one message. */
+      maxRows?: number; /** Maximum user-visible button label length. */
+      maxLabelLength?: number; /** Maximum callback/action value size in UTF-8 bytes. */
+      maxValueBytes?: number; /** Whether action styles such as primary or danger are preserved. */
+      supportsStyles?: boolean; /** Whether disabled button state is preserved. */
+      supportsDisabled?: boolean; /** Whether priority/layout hints affect native rendering. */
+      supportsLayoutHints?: boolean;
+    };
+    selects?: {
+      /** Maximum options in one select/menu block. */maxOptions?: number; /** Maximum user-visible option label length. */
+      maxLabelLength?: number; /** Maximum option callback value size in UTF-8 bytes. */
+      maxValueBytes?: number;
+    };
+    text?: {
+      /** Maximum text length for title, text, and context blocks. */maxLength?: number; /** Unit used by maxLength. Defaults to Unicode code points. */
+      encoding?: "characters" | "utf8-bytes" | "utf16-units"; /** Markdown dialect understood by rendered text blocks. */
+      markdownDialect?: "plain" | "markdown" | "html" | "slack-mrkdwn" | "discord-markdown"; /** Whether the channel can edit presentation text in-place. */
+      supportsEdit?: boolean;
+    };
+  };
+};
+type ChannelDeliveryCapabilities = {
+  pin?: boolean;
+  durableFinal?: {
+    text?: boolean;
+    media?: boolean;
+    poll?: boolean;
+    payload?: boolean;
+    silent?: boolean;
+    replyTo?: boolean;
+    thread?: boolean;
+    nativeQuote?: boolean;
+    messageSendingHooks?: boolean;
+    batch?: boolean;
+    reconcileUnknownSend?: boolean;
+    afterSendSuccess?: boolean;
+    afterCommit?: boolean;
+  };
+};
+type ChannelOutboundPayloadHint = {
+  kind: "approval-pending";
+  approvalKind: "exec" | "plugin";
+  nativeRouteActive?: boolean;
+} | {
+  kind: "approval-resolved";
+  approvalKind: "exec" | "plugin";
+};
+type ChannelOutboundTargetRef = {
+  channel: string;
+  to: string;
+  accountId?: string | null;
+  threadId?: string | number | null;
+};
+type ChannelOutboundFormattedContext = ChannelOutboundContext & {
+  abortSignal?: AbortSignal;
+};
+type ChannelOutboundChunkContext = {
+  formatting?: OutboundDeliveryFormattingOptions;
+};
+type ChannelOutboundNormalizePayloadParams = {
+  payload: ReplyPayload;
+  cfg: FengMingConfig;
+  accountId?: string | null;
+};
+type ChannelOutboundAdapter = {
+  deliveryMode: "direct" | "gateway" | "hybrid";
+  chunker?: ((text: string, limit: number, ctx?: ChannelOutboundChunkContext) => string[]) | null;
+  chunkerMode?: "text" | "markdown";
+  chunkedTextFormatting?: OutboundDeliveryFormattingOptions; /** Lift remote Markdown image syntax in text into outbound media attachments. */
+  extractMarkdownImages?: boolean;
+  textChunkLimit?: number;
+  sanitizeText?: (params: {
+    text: string;
+    payload: ReplyPayload;
+  }) => string;
+  pollMaxOptions?: number;
+  supportsPollDurationSeconds?: boolean;
+  supportsAnonymousPolls?: boolean;
+  normalizePayload?: (params: ChannelOutboundNormalizePayloadParams) => ReplyPayload | null;
+  sendTextOnlyErrorPayloads?: boolean;
+  shouldSkipPlainTextSanitization?: (params: {
+    payload: ReplyPayload;
+  }) => boolean;
+  resolveEffectiveTextChunkLimit?: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    fallbackLimit?: number;
+  }) => number | undefined;
+  shouldSuppressLocalPayloadPrompt?: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+    payload: ReplyPayload;
+    hint?: ChannelOutboundPayloadHint;
+  }) => boolean;
+  beforeDeliverPayload?: (params: {
+    cfg: FengMingConfig;
+    target: ChannelOutboundTargetRef;
+    payload: ReplyPayload;
+    hint?: ChannelOutboundPayloadHint;
+  }) => Promise<void> | void;
+  afterDeliverPayload?: (params: {
+    cfg: FengMingConfig;
+    target: ChannelOutboundTargetRef;
+    payload: ReplyPayload;
+    results: readonly OutboundDeliveryResult[];
+  }) => Promise<void> | void; /** Channel-advertised presentation features and limits used by core adaptation. */
+  presentationCapabilities?: ChannelPresentationCapabilities;
+  deliveryCapabilities?: ChannelDeliveryCapabilities; /** Render an adapted portable presentation into channel-native payload data. */
+  renderPresentation?: (params: {
+    payload: ReplyPayload;
+    presentation: MessagePresentation;
+    ctx: ChannelOutboundPayloadContext;
+  }) => Promise<ReplyPayload | null> | ReplyPayload | null;
+  pinDeliveredMessage?: (params: {
+    cfg: FengMingConfig;
+    target: ChannelOutboundTargetRef;
+    messageId: string;
+    pin: ReplyPayloadDeliveryPin;
+    gatewayClientScopes?: readonly string[];
+  }) => Promise<void> | void;
+  /**
+   * @deprecated Use shouldTreatDeliveredTextAsVisible instead.
+   */
+  shouldTreatRoutedTextAsVisible?: (params: {
+    kind: "tool" | "block" | "final";
+    text?: string;
+  }) => boolean;
+  shouldTreatDeliveredTextAsVisible?: (params: {
+    kind: "tool" | "block" | "final";
+    text?: string;
+  }) => boolean;
+  preferFinalAssistantVisibleText?: boolean;
+  targetsMatchForReplySuppression?: (params: {
+    originTarget: string;
+    targetKey: string;
+    targetThreadId?: string;
+  }) => boolean;
+  resolveTarget?: (params: {
+    cfg?: FengMingConfig;
+    to?: string;
+    allowFrom?: string[];
+    accountId?: string | null;
+    mode?: ChannelOutboundTargetMode;
+  }) => {
+    ok: true;
+    to: string;
+  } | {
+    ok: false;
+    error: Error;
+  };
+  sendPayload?: (ctx: ChannelOutboundPayloadContext) => Promise<OutboundDeliveryResult>;
+  sendFormattedText?: (ctx: ChannelOutboundFormattedContext) => Promise<OutboundDeliveryResult[]>;
+  sendFormattedMedia?: (ctx: ChannelOutboundFormattedContext & {
+    mediaUrl: string;
+  }) => Promise<OutboundDeliveryResult>;
+  sendText?: (ctx: ChannelOutboundContext) => Promise<OutboundDeliveryResult>;
+  sendMedia?: (ctx: ChannelOutboundContext) => Promise<OutboundDeliveryResult>;
+  sendPoll?: (ctx: ChannelPollContext) => Promise<ChannelPollResult>;
+};
+//#endregion
+export { OutboundPayloadDeliverySuppressionReason as S, chunkTextWithMode as _, ChannelOutboundFormattedContext as a, OutboundDeliveryResult as b, ChannelOutboundTargetRef as c, OutboundDeliveryFormattingOptions as d, ChunkMode as f, chunkText as g, chunkMarkdownTextWithMode as h, ChannelOutboundContext as i, ChannelPresentationCapabilities as l, chunkMarkdownText as m, ChannelOutboundAdapter as n, ChannelOutboundPayloadContext as o, chunkByNewline as p, ChannelOutboundChunkContext as r, ChannelOutboundPayloadHint as s, ChannelDeliveryCapabilities as t, OutboundIdentity as u, resolveChunkMode as v, OutboundPayloadDeliveryOutcome as x, resolveTextChunkLimit as y };

package/dist/plugin-enabled-fvhTpvYS.js

@@ -0,0 +1,232 @@
+import { t as collectErrorGraphCandidates } from "./errors-C_Wa6a5T.js";
+import { d as registerUnhandledRejectionHandler } from "./unhandled-rejections-CyXc0Srv.js";
+import { c as resolveEffectiveEnableState, s as normalizePluginsConfig } from "./config-state-DuITXGx-.js";
+import { a as isSubagentSessionKey, i as isCronSessionKey, n as isAcpSessionKey } from "./session-key-utils-CdfsDYvz.js";
+import { i as getRuntimeConfig } from "./io-T1CV3Z1L.js";
+import "./error-runtime-De5jjTLl.js";
+import "./runtime-env-CvWo8qXm.js";
+import "./routing-B7t3bis6.js";
+import { n as resolveBrowserConfig } from "./config-BJJhHN9E.js";
+import { n as sweepTrackedBrowserTabs } from "./session-tab-registry-C2eElZrt.js";
+import { n as listKnownProfileNames, t as createBrowserRouteContext } from "./server-context-CB_an9iy.js";
+import { o as stopFengMingChrome } from "./chrome-B2cq8YyH.js";
+import { n as getPwAiModule } from "./target-id-BR2xJIkd.js";
+import { t as isPwAiLoaded } from "./pw-ai-state-DL7FXLI8.js";
+//#region extensions/browser/src/browser/server-lifecycle.ts
+async function ensureExtensionRelayForProfiles(_params) {}
+async function stopKnownBrowserProfiles(params) {
+	const current = params.getState();
+	if (!current) return;
+	const ctx = createBrowserRouteContext({
+		getState: params.getState,
+		refreshConfigFromDisk: true
+	});
+	try {
+		for (const name of listKnownProfileNames(current)) try {
+			const runtime = current.profiles.get(name);
+			if (runtime?.running) {
+				await stopFengMingChrome(runtime.running);
+				runtime.running = null;
+				continue;
+			}
+			await ctx.forProfile(name).stopRunningBrowser();
+		} catch {}
+	} catch (err) {
+		params.onWarn(`fengming browser stop failed: ${String(err)}`);
+	}
+}
+//#endregion
+//#region extensions/browser/src/browser/session-tab-cleanup.ts
+const MIN_SWEEP_INTERVAL_MS = 6e4;
+function minutesToMs(minutes) {
+	return Math.max(0, Math.floor(minutes * 6e4));
+}
+function isPrimaryTrackedBrowserSessionKey(sessionKey) {
+	return !isSubagentSessionKey(sessionKey) && !isCronSessionKey(sessionKey) && !isAcpSessionKey(sessionKey);
+}
+function resolveBrowserTabCleanupRuntimeConfig() {
+	const cfg = getRuntimeConfig();
+	return resolveBrowserConfig(cfg.browser, cfg).tabCleanup;
+}
+async function runTrackedBrowserTabCleanupOnce(params) {
+	const cleanup = params?.cleanup ?? resolveBrowserTabCleanupRuntimeConfig();
+	if (!cleanup.enabled) return 0;
+	return await sweepTrackedBrowserTabs({
+		now: params?.now,
+		idleMs: minutesToMs(cleanup.idleMinutes),
+		maxTabsPerSession: cleanup.maxTabsPerSession,
+		sessionFilter: isPrimaryTrackedBrowserSessionKey,
+		closeTab: params?.closeTab,
+		onWarn: params?.onWarn
+	});
+}
+function startTrackedBrowserTabCleanupTimer(params) {
+	let stopped = false;
+	let timer = null;
+	let running = null;
+	const schedule = () => {
+		if (stopped) return;
+		let sweepMinutes = 5;
+		try {
+			sweepMinutes = resolveBrowserTabCleanupRuntimeConfig().sweepMinutes;
+		} catch (err) {
+			params.onWarn(`failed to resolve browser tab cleanup config: ${String(err)}`);
+		}
+		timer = setTimeout(run, Math.max(MIN_SWEEP_INTERVAL_MS, minutesToMs(sweepMinutes)));
+		timer.unref?.();
+	};
+	const run = () => {
+		if (stopped) return;
+		if (!running) {
+			running = runTrackedBrowserTabCleanupOnce({ onWarn: params.onWarn }).finally(() => {
+				running = null;
+				schedule();
+			});
+			return;
+		}
+		schedule();
+	};
+	schedule();
+	return () => {
+		stopped = true;
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+		}
+	};
+}
+//#endregion
+//#region extensions/browser/src/browser/unhandled-rejections.ts
+const PLAYWRIGHT_DIALOG_METHODS = new Set(["Page.handleJavaScriptDialog", "Dialog.handleJavaScriptDialog"]);
+const NO_DIALOG_MESSAGE = "no dialog is showing";
+function readMessage(err) {
+	if (typeof err === "string") return err;
+	if (!err || typeof err !== "object") return "";
+	const message = err.message;
+	return typeof message === "string" ? message : "";
+}
+function readPlaywrightMethod(err) {
+	if (!err || typeof err !== "object") return;
+	const method = err.method;
+	return typeof method === "string" ? method : void 0;
+}
+function isPlaywrightDialogRaceUnhandledRejection(reason) {
+	for (const candidate of collectErrorGraphCandidates(reason, (current) => [
+		current.cause,
+		current.reason,
+		current.original,
+		current.error,
+		current.data,
+		...Array.isArray(current.errors) ? current.errors : []
+	])) {
+		const message = readMessage(candidate);
+		if (!message.toLowerCase().includes(NO_DIALOG_MESSAGE)) continue;
+		const method = readPlaywrightMethod(candidate);
+		if (method && PLAYWRIGHT_DIALOG_METHODS.has(method)) return true;
+		for (const playwrightMethod of PLAYWRIGHT_DIALOG_METHODS) if (message.includes(playwrightMethod)) return true;
+	}
+	return false;
+}
+function registerBrowserUnhandledRejectionHandler() {
+	return registerUnhandledRejectionHandler(isPlaywrightDialogRaceUnhandledRejection);
+}
+//#endregion
+//#region extensions/browser/src/browser/runtime-lifecycle.ts
+async function createBrowserRuntimeState(params) {
+	const state = {
+		server: params.server ?? null,
+		port: params.port,
+		resolved: params.resolved,
+		profiles: /* @__PURE__ */ new Map()
+	};
+	state.stopTrackedTabCleanup = startTrackedBrowserTabCleanupTimer({ onWarn: params.onWarn });
+	await ensureExtensionRelayForProfiles({
+		resolved: params.resolved,
+		onWarn: params.onWarn
+	});
+	state.stopUnhandledRejectionHandler = registerBrowserUnhandledRejectionHandler();
+	return state;
+}
+async function stopBrowserRuntime(params) {
+	if (!params.current) return;
+	try {
+		params.current.stopTrackedTabCleanup?.();
+		await stopKnownBrowserProfiles({
+			getState: params.getState,
+			onWarn: params.onWarn
+		});
+		if (params.closeServer && params.current.server) await new Promise((resolve) => {
+			params.current?.server?.close(() => resolve());
+		});
+		params.clearState();
+		if (!isPwAiLoaded()) return;
+		try {
+			await (await getPwAiModule({ mode: "soft" }))?.closePlaywrightBrowserConnection();
+		} catch {}
+	} finally {
+		params.current.stopUnhandledRejectionHandler?.();
+	}
+}
+//#endregion
+//#region extensions/browser/src/browser-control-state.ts
+let state = null;
+let owner = null;
+function getBrowserControlState() {
+	return state;
+}
+function createBrowserControlContext() {
+	return createBrowserRouteContext({
+		getState: () => state,
+		refreshConfigFromDisk: true
+	});
+}
+async function ensureBrowserControlRuntime(params) {
+	if (state) {
+		if (params.server) {
+			state.server = params.server;
+			state.port = params.port;
+			state.resolved = {
+				...params.resolved,
+				controlPort: params.port
+			};
+			owner = "server";
+		}
+		return state;
+	}
+	state = await createBrowserRuntimeState({
+		server: params.server ?? null,
+		port: params.port,
+		resolved: params.resolved,
+		onWarn: params.onWarn
+	});
+	owner = params.owner;
+	return state;
+}
+async function stopBrowserControlRuntime(params) {
+	const current = state;
+	if (!current) return;
+	if (params.requestedBy === "service" && current.server && owner === "server") return;
+	await stopBrowserRuntime({
+		current,
+		getState: () => state,
+		clearState: () => {
+			state = null;
+			owner = null;
+		},
+		closeServer: params.closeServer,
+		onWarn: params.onWarn
+	});
+}
+//#endregion
+//#region extensions/browser/src/plugin-enabled.ts
+function isDefaultBrowserPluginEnabled(cfg) {
+	return resolveEffectiveEnableState({
+		id: "browser",
+		origin: "bundled",
+		config: normalizePluginsConfig(cfg.plugins),
+		rootConfig: cfg,
+		enabledByDefault: true
+	}).enabled;
+}
+//#endregion
+export { stopBrowserControlRuntime as a, getBrowserControlState as i, createBrowserControlContext as n, createBrowserRuntimeState as o, ensureBrowserControlRuntime as r, stopBrowserRuntime as s, isDefaultBrowserPluginEnabled as t };

package/dist/plugin-entry-CunlVUw6.d.ts

@@ -0,0 +1,47 @@
+import { g as FengMingPluginDefinition, h as FengMingPluginConfigSchema, l as FengMingPluginApi } from "./types-BQw1qXGl.js";
+//#region src/plugin-sdk/plugin-entry.d.ts
+/** Options for a plugin entry that registers providers, tools, commands, or services. */
+type DefinePluginEntryOptions = {
+  id: string;
+  name: string;
+  description: string;
+  /**
+   * @deprecated Declare exclusive plugin kind in `fengming.plugin.json` via
+   * manifest `kind`. Runtime-entry `kind` remains only as a compatibility
+   * fallback for older plugins.
+   */
+  kind?: FengMingPluginDefinition["kind"];
+  configSchema?: FengMingPluginConfigSchema | (() => FengMingPluginConfigSchema);
+  reload?: FengMingPluginDefinition["reload"];
+  nodeHostCommands?: FengMingPluginDefinition["nodeHostCommands"];
+  securityAuditCollectors?: FengMingPluginDefinition["securityAuditCollectors"];
+  register: (api: FengMingPluginApi) => void;
+};
+/** Normalized object shape that FengMing loads from a plugin entry module. */
+type DefinedPluginEntry = {
+  id: string;
+  name: string;
+  description: string;
+  configSchema: FengMingPluginConfigSchema;
+  register: NonNullable<FengMingPluginDefinition["register"]>;
+} & Pick<FengMingPluginDefinition, "kind" | "reload" | "nodeHostCommands" | "securityAuditCollectors">;
+/**
+ * Canonical entry helper for non-channel plugins.
+ *
+ * Use this for provider, tool, command, service, memory, and context-engine
+ * plugins. Channel plugins should use `defineChannelPluginEntry(...)` from
+ * `fengming/plugin-sdk/core` so they inherit the channel capability wiring.
+ */
+declare function definePluginEntry({
+  id,
+  name,
+  description,
+  kind,
+  configSchema,
+  reload,
+  nodeHostCommands,
+  securityAuditCollectors,
+  register
+}: DefinePluginEntryOptions): DefinedPluginEntry;
+//#endregion
+export { definePluginEntry as t };

package/dist/plugin-registration-9ovnK_Tk.js

@@ -0,0 +1,97 @@
+import { n as BROWSER_REQUEST_GATEWAY_SCOPE, t as BROWSER_REQUEST_GATEWAY_METHOD } from "./browser-gateway-contract-yfVqwwwt.js";
+import { t as BrowserToolSchema } from "./browser-tool.schema-CbEsgQNW.js";
+//#region extensions/browser/plugin-registration.ts
+const EAGER_BROWSER_CONTROL_SERVICE_ENV = "FENGMING_EAGER_BROWSER_CONTROL_SERVER";
+function isTruthyEnvValue(value) {
+	return /^(?:1|true|yes|on)$/iu.test(value?.trim() ?? "");
+}
+const BROWSER_CLI_DESCRIPTOR = {
+	name: "browser",
+	description: "Manage FengMing's dedicated browser (Chrome/Chromium)",
+	hasSubcommands: true
+};
+function createLazyBrowserTool(opts) {
+	const targetDefault = opts?.sandboxBridgeUrl ? "sandbox" : "host";
+	const hostHint = opts?.allowHostControl === false ? "Host target blocked by policy." : "Host target allowed.";
+	return {
+		label: "Browser",
+		name: "browser",
+		description: [
+			"Control the browser via FengMing's browser control server (status/start/stop/profiles/tabs/open/snapshot/screenshot/actions).",
+			"Browser choice: omit profile by default for the isolated FengMing-managed browser (`fengming`).",
+			"For the logged-in user browser, use profile=\"user\". A supported Chromium-based browser (v144+) must be running on the selected host or browser node. Use only when existing logins/cookies matter and the user is present.",
+			"For profile=\"user\" or other existing-session profiles, omit timeoutMs on act:type, evaluate, hover, scrollIntoView, drag, select, and fill; that driver rejects per-call timeout overrides for those actions.",
+			"When a node-hosted browser proxy is available, the tool may auto-route to it. Pin a node with node=<id|name> or target=\"node\".",
+			"When using refs from snapshot (e.g. e12), keep the same tab: prefer passing targetId from the snapshot response into subsequent actions (act/click/type/etc). For tab operations, targetId also accepts tabId handles (t1) and labels from action=tabs.",
+			"For multi-step browser work, login checks, stale refs, duplicate tabs, or Google Meet flows, use the bundled browser-automation skill when it is available.",
+			"For stable, self-resolving refs across calls, use snapshot with refs=\"aria\" (Playwright aria-ref ids). Default refs=\"role\" are role+name-based.",
+			"Use snapshot+act for UI automation. Avoid act:wait by default; use only in exceptional cases when no reliable UI state exists.",
+			`target selects browser location (sandbox|host|node). Default: ${targetDefault}.`,
+			hostHint
+		].join(" "),
+		parameters: BrowserToolSchema,
+		execute: async (toolCallId, args, signal, onUpdate) => {
+			const { createBrowserTool } = await import("./extensions/browser/register.runtime.js");
+			return await createBrowserTool(opts).execute(toolCallId, args, signal, onUpdate);
+		}
+	};
+}
+const browserPluginReload = { restartPrefixes: ["browser"] };
+const browserPluginNodeHostCommands = [{
+	command: "browser.proxy",
+	cap: "browser",
+	handle: async (paramsJSON) => {
+		const { runBrowserProxyCommand } = await import("./extensions/browser/register.runtime.js");
+		return await runBrowserProxyCommand(paramsJSON);
+	}
+}];
+const browserSecurityAuditCollectors = [async (ctx) => {
+	const { collectBrowserSecurityAuditFindings } = await import("./extensions/browser/register.runtime.js");
+	return collectBrowserSecurityAuditFindings(ctx);
+}];
+function createLazyBrowserPluginService() {
+	let service = null;
+	const loadService = async () => {
+		if (!service) {
+			const { createBrowserPluginService } = await import("./extensions/browser/register.runtime.js");
+			service = createBrowserPluginService();
+		}
+		return service;
+	};
+	return {
+		id: "browser-control",
+		start: async (ctx) => {
+			if (!isTruthyEnvValue(process.env[EAGER_BROWSER_CONTROL_SERVICE_ENV])) return;
+			await (await loadService()).start(ctx);
+		},
+		stop: async (ctx) => {
+			if (!service) {
+				const { stopBrowserControlService } = await import("./control-service-BGpHj7RL.js");
+				await stopBrowserControlService().catch(() => {});
+				return;
+			}
+			await service.stop?.(ctx);
+		}
+	};
+}
+function registerBrowserPlugin(api) {
+	api.registerTool(((ctx) => createLazyBrowserTool({
+		sandboxBridgeUrl: ctx.browser?.sandboxBridgeUrl,
+		allowHostControl: ctx.browser?.allowHostControl,
+		agentSessionKey: ctx.sessionKey
+	})));
+	api.registerCli(async ({ program }) => {
+		const { registerBrowserCli } = await import("./browser-cli-B0Ou-Nbm.js");
+		registerBrowserCli(program);
+	}, {
+		commands: ["browser"],
+		descriptors: [BROWSER_CLI_DESCRIPTOR]
+	});
+	api.registerGatewayMethod(BROWSER_REQUEST_GATEWAY_METHOD, async (opts) => {
+		const { handleBrowserGatewayRequest } = await import("./extensions/browser/register.runtime.js");
+		return await handleBrowserGatewayRequest(opts);
+	}, { scope: BROWSER_REQUEST_GATEWAY_SCOPE });
+	api.registerService(createLazyBrowserPluginService());
+}
+//#endregion
+export { registerBrowserPlugin as i, browserPluginReload as n, browserSecurityAuditCollectors as r, browserPluginNodeHostCommands as t };