fengming 0.3.4 → 0.3.5

package/dist/read-file-ogB-HjbK.js

@@ -0,0 +1,183 @@
+import { a as isPathInsideWithRealpath, i as isPathInside } from "./path-BlG8lhgR.js";
+import { a as root } from "./secure-temp-dir-BvCzS-gM.js";
+import { t as assertNoSymlinkParents } from "./symlink-parents-LGlX4F0x.js";
+import { o as statRegularFile, r as readRegularFile } from "./regular-file-BD2zl6_l.js";
+import { t as isFileMissingError } from "./fs-utils-D05rps7O.js";
+import { a as resolveAgentWorkspaceDir, i as resolveAgentContextLimits, o as resolveMemorySearchConfig } from "./config-utils-Bv0Nisds.js";
+import { c as normalizeExtraMemoryPaths, o as isMemoryPath } from "./internal-DL_vFx8C.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region packages/memory-host-sdk/src/host/read-file-shared.ts
+const DEFAULT_MEMORY_READ_LINES = 120;
+const DEFAULT_MEMORY_READ_MAX_CHARS = 12e3;
+function buildContinuationNotice(params) {
+	const base = typeof params.nextFrom === "number" ? `[More content available. Use from=${params.nextFrom} to continue.]` : "[More content available. Requested excerpt exceeded the default maxChars budget.]";
+	const fallback = params.suggestReadFallback ? " If you need the full raw line, use read on the source file." : "";
+	return `\n\n${base.slice(0, -1)}${fallback}]`;
+}
+function fitLinesToCharBudget(params) {
+	const { lines, maxChars } = params;
+	if (lines.length === 0) return {
+		text: "",
+		includedLines: 0,
+		hardTruncatedSingleLine: false
+	};
+	let includedLines = lines.length;
+	let text = lines.join("\n");
+	while (includedLines > 1 && text.length > maxChars) {
+		includedLines -= 1;
+		text = lines.slice(0, includedLines).join("\n");
+	}
+	if (text.length <= maxChars) return {
+		text,
+		includedLines,
+		hardTruncatedSingleLine: false
+	};
+	return {
+		text: text.slice(0, maxChars),
+		includedLines: 1,
+		hardTruncatedSingleLine: true
+	};
+}
+function normalizePositiveInteger(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(1, Math.floor(value)) : fallback;
+}
+function buildMemoryReadResultFromSlice(params) {
+	const start = normalizePositiveInteger(params.startLine, 1);
+	const fitted = fitLinesToCharBudget({
+		lines: params.selectedLines,
+		maxChars: normalizePositiveInteger(params.maxChars, DEFAULT_MEMORY_READ_MAX_CHARS)
+	});
+	const moreSourceLinesRemain = params.moreSourceLinesRemain ?? false;
+	const charCapTruncated = fitted.hardTruncatedSingleLine || fitted.includedLines < params.selectedLines.length;
+	const nextFrom = !fitted.hardTruncatedSingleLine && (moreSourceLinesRemain || fitted.includedLines < params.selectedLines.length) ? start + fitted.includedLines : void 0;
+	const truncated = charCapTruncated || moreSourceLinesRemain;
+	return {
+		text: truncated && fitted.text ? `${fitted.text}${buildContinuationNotice({
+			nextFrom,
+			suggestReadFallback: fitted.hardTruncatedSingleLine && params.suggestReadFallback
+		})}` : fitted.text,
+		path: params.relPath,
+		from: start,
+		lines: fitted.includedLines,
+		...truncated ? { truncated: true } : {},
+		...typeof nextFrom === "number" ? { nextFrom } : {}
+	};
+}
+function buildMemoryReadResult(params) {
+	const fileLines = params.content.split("\n");
+	const start = normalizePositiveInteger(params.from, 1);
+	const requestedCount = normalizePositiveInteger(params.lines ?? params.defaultLines, 120);
+	const selectedLines = fileLines.slice(start - 1, start - 1 + requestedCount);
+	const moreSourceLinesRemain = start - 1 + selectedLines.length < fileLines.length;
+	return buildMemoryReadResultFromSlice({
+		selectedLines,
+		relPath: params.relPath,
+		startLine: start,
+		moreSourceLinesRemain,
+		maxChars: params.maxChars,
+		suggestReadFallback: params.suggestReadFallback
+	});
+}
+//#endregion
+//#region packages/memory-host-sdk/src/host/read-file.ts
+async function isAllowedAdditionalDirectoryPath(additionalPath, absPath) {
+	if (!isPathInside(additionalPath, absPath)) return false;
+	try {
+		await assertNoSymlinkParents({
+			rootDir: additionalPath,
+			targetPath: absPath
+		});
+	} catch {
+		return false;
+	}
+	if (!isPathInsideWithRealpath(additionalPath, absPath)) {
+		try {
+			await fs.lstat(absPath);
+		} catch (err) {
+			return isFileMissingError(err);
+		}
+		return false;
+	}
+	return true;
+}
+function isFileDisappearedDuringReadError(err) {
+	return isFileMissingError(err) || Boolean(err && typeof err === "object" && "code" in err && err.code === "path-mismatch");
+}
+async function readMemoryFile(params) {
+	const rawPath = params.relPath.trim();
+	if (!rawPath) throw new Error("路径是必需的");
+	const absPath = path.isAbsolute(rawPath) ? path.resolve(rawPath) : path.resolve(params.workspaceDir, rawPath);
+	const relPath = path.relative(params.workspaceDir, absPath).replace(/\\/g, "/");
+	const allowedWorkspace = relPath.length > 0 && !relPath.startsWith("..") && !path.isAbsolute(relPath) && isMemoryPath(relPath);
+	let allowedAdditional = false;
+	if (!allowedWorkspace && (params.extraPaths?.length ?? 0) > 0) {
+		const additionalPaths = normalizeExtraMemoryPaths(params.workspaceDir, params.extraPaths);
+		for (const additionalPath of additionalPaths) try {
+			const stat = await fs.lstat(additionalPath);
+			if (stat.isSymbolicLink()) continue;
+			if (stat.isDirectory()) {
+				if (await isAllowedAdditionalDirectoryPath(additionalPath, absPath)) {
+					if ((await fs.lstat(absPath).catch(() => null))?.isSymbolicLink()) continue;
+					allowedAdditional = true;
+					break;
+				}
+				continue;
+			}
+			if (stat.isFile() && absPath === additionalPath && absPath.endsWith(".md")) {
+				allowedAdditional = true;
+				break;
+			}
+		} catch {}
+	}
+	if (!allowedWorkspace && !allowedAdditional) throw new Error("路径是必需的");
+	if (!absPath.endsWith(".md")) throw new Error("路径是必需的");
+	if (allowedWorkspace) try {
+		await (await root(params.workspaceDir)).resolve(relPath);
+	} catch (err) {
+		if (isFileMissingError(err)) return {
+			text: "",
+			path: relPath
+		};
+		throw err;
+	}
+	if ((await statRegularFile(absPath)).missing) return {
+		text: "",
+		path: relPath
+	};
+	let content;
+	try {
+		content = (await readRegularFile({ filePath: absPath })).buffer.toString("utf-8");
+	} catch (err) {
+		if (isFileDisappearedDuringReadError(err)) return {
+			text: "",
+			path: relPath
+		};
+		throw err;
+	}
+	return buildMemoryReadResult({
+		content,
+		relPath,
+		from: params.from,
+		lines: params.lines,
+		defaultLines: params.defaultLines ?? 120,
+		maxChars: params.maxChars,
+		suggestReadFallback: allowedWorkspace
+	});
+}
+async function readAgentMemoryFile(params) {
+	const settings = resolveMemorySearchConfig(params.cfg, params.agentId);
+	if (!settings) throw new Error("memory search disabled");
+	const contextLimits = resolveAgentContextLimits(params.cfg, params.agentId);
+	return await readMemoryFile({
+		workspaceDir: resolveAgentWorkspaceDir(params.cfg, params.agentId),
+		extraPaths: settings.extraPaths,
+		relPath: params.relPath,
+		from: params.from,
+		lines: params.lines,
+		defaultLines: contextLimits?.memoryGetDefaultLines,
+		maxChars: contextLimits?.memoryGetMaxChars
+	});
+}
+//#endregion
+export { buildMemoryReadResult as a, DEFAULT_MEMORY_READ_MAX_CHARS as i, readMemoryFile as n, buildMemoryReadResultFromSlice as o, DEFAULT_MEMORY_READ_LINES as r, readAgentMemoryFile as t };

package/dist/register-service-commands-D_gQ3b6_.js

@@ -0,0 +1,77 @@
+import { t as createLazyImportLoader } from "./lazy-promise-Djskx0qC.js";
+import { n as inheritOptionFromParent } from "./command-options-Dhjl7AMa.js";
+//#region src/cli/daemon-cli/register-service-commands.ts
+const daemonInstallModuleLoader = createLazyImportLoader(() => import("./install.runtime-Zye6pbZ6.js"));
+const daemonLifecycleModuleLoader = createLazyImportLoader(() => import("./lifecycle.runtime.js"));
+const daemonStatusModuleLoader = createLazyImportLoader(() => import("./status.runtime-D3oln_Mg.js"));
+function loadDaemonInstallModule() {
+	return daemonInstallModuleLoader.load();
+}
+function loadDaemonLifecycleModule() {
+	return daemonLifecycleModuleLoader.load();
+}
+function loadDaemonStatusModule() {
+	return daemonStatusModuleLoader.load();
+}
+function resolveInstallOptions(cmdOpts, command) {
+	const parentForce = inheritOptionFromParent(command, "force");
+	const parentPort = inheritOptionFromParent(command, "port");
+	const parentToken = inheritOptionFromParent(command, "token");
+	return {
+		...cmdOpts,
+		force: Boolean(cmdOpts.force || parentForce),
+		port: cmdOpts.port ?? parentPort,
+		token: cmdOpts.token ?? parentToken
+	};
+}
+function resolveRpcOptions(cmdOpts, command) {
+	const parentToken = inheritOptionFromParent(command, "token");
+	const parentPassword = inheritOptionFromParent(command, "password");
+	return {
+		...cmdOpts,
+		token: cmdOpts.token ?? parentToken,
+		password: cmdOpts.password ?? parentPassword
+	};
+}
+function resolveRestartOptions(cmdOpts, command) {
+	const parentForce = inheritOptionFromParent(command, "force");
+	return {
+		...cmdOpts,
+		force: Boolean(cmdOpts.force || parentForce),
+		safe: Boolean(cmdOpts.safe)
+	};
+}
+function addGatewayServiceCommands(parent, opts) {
+	parent.command("status").description(opts?.statusDescription ?? "Show gateway service status + probe connectivity/capability").option("--url <url>", "Gateway WebSocket URL (defaults to config/remote/local)").option("--token <token>", "Gateway token (if required)").option("--password <password>", "Gateway password (password auth)").option("--timeout <ms>", "Timeout in ms", "10000").option("--no-probe", "Skip RPC probe").option("--require-rpc", "Exit non-zero when the RPC probe fails", false).option("--deep", "Scan system-level services", false).option("--json", "Output JSON", false).action(async (cmdOpts, command) => {
+		const { runDaemonStatus } = await loadDaemonStatusModule();
+		await runDaemonStatus({
+			rpc: resolveRpcOptions(cmdOpts, command),
+			probe: Boolean(cmdOpts.probe),
+			requireRpc: Boolean(cmdOpts.requireRpc),
+			deep: Boolean(cmdOpts.deep),
+			json: Boolean(cmdOpts.json)
+		});
+	});
+	parent.command("install").description("Install the Gateway service (launchd/systemd/schtasks)").option("--port <port>", "Gateway port").option("--runtime <runtime>", "Daemon runtime (node|bun). Default: node").option("--token <token>", "Gateway token (token auth)").option("--wrapper <path>", "Executable wrapper for generated service ProgramArguments").option("--force", "Reinstall/overwrite if already installed", false).option("--json", "Output JSON", false).action(async (cmdOpts, command) => {
+		const { runDaemonInstall } = await loadDaemonInstallModule();
+		await runDaemonInstall(resolveInstallOptions(cmdOpts, command));
+	});
+	parent.command("uninstall").description("Uninstall the Gateway service (launchd/systemd/schtasks)").option("--json", "Output JSON", false).action(async (cmdOpts) => {
+		const { runDaemonUninstall } = await loadDaemonLifecycleModule();
+		await runDaemonUninstall(cmdOpts);
+	});
+	parent.command("start").description("Start the Gateway service (launchd/systemd/schtasks)").option("--json", "Output JSON", false).action(async (cmdOpts) => {
+		const { runDaemonStart } = await loadDaemonLifecycleModule();
+		await runDaemonStart(cmdOpts);
+	});
+	parent.command("stop").description("Stop the Gateway service (launchd/systemd/schtasks)").option("--json", "Output JSON", false).option("--disable", "Persistently suppress KeepAlive/RunAtLoad so the gateway does not respawn until next start (launchd only)", false).action(async (cmdOpts) => {
+		const { runDaemonStop } = await loadDaemonLifecycleModule();
+		await runDaemonStop(cmdOpts);
+	});
+	parent.command("restart").description("Restart the Gateway service (launchd/systemd/schtasks)").option("--force", "Restart immediately without waiting for active gateway work", false).option("--safe", "Request an FengMing-aware restart after active work drains", false).option("--skip-deferral", "Bypass the safe-restart deferral gate; requires --safe", false).option("--wait <duration>", "Wait duration before forcing restart (ms, 10s, 5m; 0 waits indefinitely)").option("--json", "Output JSON", false).action(async (cmdOpts, command) => {
+		const { runDaemonRestart } = await loadDaemonLifecycleModule();
+		await runDaemonRestart(resolveRestartOptions(cmdOpts, command));
+	});
+}
+//#endregion
+export { addGatewayServiceCommands as t };

package/dist/register.agent-DXQLn-r0.js

@@ -0,0 +1,152 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DKw2K5wM.js";
+import { t as formatDocsLink } from "./links-CgdQazeA.js";
+import { r as theme } from "./theme-CLQ2HbnQ.js";
+import { t as hasExplicitOptions } from "./command-options-Dhjl7AMa.js";
+import { n as defaultRuntime } from "./runtime-BkTkFkXs.js";
+import { n as runCommandWithRuntime } from "./cli-utils-JYDDzCMN.js";
+import { t as formatHelpExamples } from "./help-format-CBGqVsX5.js";
+import { t as collectOption } from "./helpers-yckYmcNJ.js";
+//#region src/cli/program/register.agent.ts
+async function loadAgentCliCommand() {
+	return (await import("./agent-via-gateway-DfKij3De.js")).agentCliCommand;
+}
+async function loadAgentsAddCommand() {
+	return (await import("./agents.commands.add-DknGM1oz.js")).agentsAddCommand;
+}
+async function loadAgentsBindCommand() {
+	return (await import("./agents.commands.bind-DDVI0yDe.js")).agentsBindCommand;
+}
+async function loadAgentsBindingsCommand() {
+	return (await import("./agents.commands.bind-DDVI0yDe.js")).agentsBindingsCommand;
+}
+async function loadAgentsUnbindCommand() {
+	return (await import("./agents.commands.bind-DDVI0yDe.js")).agentsUnbindCommand;
+}
+async function loadAgentsDeleteCommand() {
+	return (await import("./agents.commands.delete-Dv4RHEhc.js")).agentsDeleteCommand;
+}
+async function loadAgentsSetIdentityCommand() {
+	return (await import("./agents.commands.identity-BSZbc1QR.js")).agentsSetIdentityCommand;
+}
+async function loadAgentsListCommand() {
+	return (await import("./agents.commands.list-CA0OTw59.js")).agentsListCommand;
+}
+async function loadSetVerbose() {
+	return (await import("./global-state-B4gzUAcU.js")).setVerbose;
+}
+function registerAgentCommands(program, args) {
+	program.command("agent").description("Run an agent turn via the Gateway (use --local for embedded)").requiredOption("-m, --message <text>", "Message body for the agent").option("-t, --to <number>", "Recipient number in E.164 used to derive the session key").option("--session-key <key>", "Explicit session key (agent:<id>:<key>, or scoped to --agent)").option("--session-id <id>", "Use an explicit session id").option("--agent <id>", "Agent id (overrides routing bindings)").option("--model <id>", "Model override for this run (provider/model or model id)").option("--thinking <level>", "Thinking level: off | minimal | low | medium | high | xhigh | adaptive | max where supported").option("--verbose <on|off>", "Persist agent verbose level for the session").option("--channel <channel>", `Delivery channel: ${args.agentChannelOptions} (omit to use the main session channel)`).option("--reply-to <target>", "Delivery target override (separate from session routing)").option("--reply-channel <channel>", "Delivery channel override (separate from routing)").option("--reply-account <id>", "Delivery account id override").option("--local", "Run the embedded agent locally (requires model provider API keys in your shell)", false).option("--deliver", "Send the agent's reply back to the selected channel", false).option("--json", "Output result as JSON", false).option("--timeout <seconds>", "Override agent command timeout (seconds, default 600 or config value)").addHelpText("after", () => `
+${theme.heading("Examples:")}
+${formatHelpExamples([
+		["fengming agent --to +15555550123 --message \"status update\"", "Start a new session."],
+		["fengming agent --agent ops --message \"Summarize logs\"", "Use a specific agent."],
+		["fengming agent --session-key agent:ops:incident-42 --message \"Summarize status\"", "Target an exact session key."],
+		["fengming agent --session-id 1234 --message \"Summarize inbox\" --thinking medium", "Target a session with explicit thinking level."],
+		["fengming agent --to +15555550123 --message \"Trace logs\" --verbose on --json", "Enable verbose logging and JSON output."],
+		["fengming agent --to +15555550123 --message \"Summon reply\" --deliver", "Deliver reply."],
+		["fengming agent --agent ops --message \"Generate report\" --deliver --reply-channel slack --reply-to \"#reports\"", "Send reply to a different channel/target."]
+	])}
+
+${theme.muted("Docs:")} ${formatDocsLink("/cli/agent", "docs.fengming.ai/cli/agent")}`).action(async (opts) => {
+		const verboseLevel = typeof opts.verbose === "string" ? normalizeLowercaseStringOrEmpty(opts.verbose) : "";
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			(await loadSetVerbose())(verboseLevel === "on");
+			await (await loadAgentCliCommand())(opts, defaultRuntime);
+		});
+	});
+	const agents = program.command("agents").description("Manage isolated agents (workspaces + auth + routing)").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/agents", "docs.fengming.ai/cli/agents")}\n`);
+	agents.command("list").description("List configured agents").option("--json", "Output JSON instead of text", false).option("--bindings", "Include routing bindings", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsListCommand())({
+				json: Boolean(opts.json),
+				bindings: Boolean(opts.bindings)
+			}, defaultRuntime);
+		});
+	});
+	agents.command("bindings").description("List routing bindings").option("--agent <id>", "Filter by agent id").option("--json", "Output JSON instead of text", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsBindingsCommand())({
+				agent: opts.agent,
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	agents.command("bind").description("Add routing bindings for an agent").option("--agent <id>", "Agent id (defaults to current default agent)").option("--bind <channel[:accountId]>", "Binding to add (repeatable). If omitted, accountId is resolved by channel defaults/hooks.", collectOption, []).option("--json", "Output JSON summary", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsBindCommand())({
+				agent: opts.agent,
+				bind: Array.isArray(opts.bind) ? opts.bind : void 0,
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	agents.command("unbind").description("Remove routing bindings for an agent").option("--agent <id>", "Agent id (defaults to current default agent)").option("--bind <channel[:accountId]>", "Binding to remove (repeatable)", collectOption, []).option("--all", "Remove all bindings for this agent", false).option("--json", "Output JSON summary", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsUnbindCommand())({
+				agent: opts.agent,
+				bind: Array.isArray(opts.bind) ? opts.bind : void 0,
+				all: Boolean(opts.all),
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	agents.command("add [name]").description("Add a new isolated agent").option("--workspace <dir>", "Workspace directory for the new agent").option("--model <id>", "Model id for this agent").option("--agent-dir <dir>", "Agent state directory for this agent").option("--bind <channel[:accountId]>", "Route channel binding (repeatable)", collectOption, []).option("--non-interactive", "Disable prompts; requires --workspace", false).option("--json", "Output JSON summary", false).action(async (name, opts, command) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const hasFlags = hasExplicitOptions(command, [
+				"workspace",
+				"model",
+				"agentDir",
+				"bind",
+				"nonInteractive"
+			]);
+			await (await loadAgentsAddCommand())({
+				name: typeof name === "string" ? name : void 0,
+				workspace: opts.workspace,
+				model: opts.model,
+				agentDir: opts.agentDir,
+				bind: Array.isArray(opts.bind) ? opts.bind : void 0,
+				nonInteractive: Boolean(opts.nonInteractive),
+				json: Boolean(opts.json)
+			}, defaultRuntime, { hasFlags });
+		});
+	});
+	agents.command("set-identity").description("Update an agent identity (name/theme/emoji/avatar)").option("--agent <id>", "Agent id to update").option("--workspace <dir>", "Workspace directory used to locate the agent + IDENTITY.md").option("--identity-file <path>", "Explicit IDENTITY.md path to read").option("--from-identity", "Read values from IDENTITY.md", false).option("--name <name>", "Identity name").option("--theme <theme>", "Identity theme").option("--emoji <emoji>", "Identity emoji").option("--avatar <value>", "Identity avatar (workspace path, http(s) URL, or data URI)").option("--json", "Output JSON summary", false).addHelpText("after", () => `
+${theme.heading("Examples:")}
+${formatHelpExamples([
+		["fengming agents set-identity --agent main --name \"FengMing\" --emoji \"🦞\"", "Set name + emoji."],
+		["fengming agents set-identity --agent main --avatar avatars/fengming.png", "Set avatar path."],
+		["fengming agents set-identity --workspace ~/.fengming/workspace --from-identity", "Load from IDENTITY.md."],
+		["fengming agents set-identity --identity-file ~/.fengming/workspace/IDENTITY.md --agent main", "Use a specific IDENTITY.md."]
+	])}
+`).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsSetIdentityCommand())({
+				agent: opts.agent,
+				workspace: opts.workspace,
+				identityFile: opts.identityFile,
+				fromIdentity: Boolean(opts.fromIdentity),
+				name: opts.name,
+				theme: opts.theme,
+				emoji: opts.emoji,
+				avatar: opts.avatar,
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	agents.command("delete <id>").description("Delete an agent and prune workspace/state").option("--force", "Skip confirmation", false).option("--json", "Output JSON summary", false).action(async (id, opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsDeleteCommand())({
+				id: String(id),
+				force: Boolean(opts.force),
+				json: Boolean(opts.json)
+			}, defaultRuntime);
+		});
+	});
+	agents.action(async () => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await (await loadAgentsListCommand())({}, defaultRuntime);
+		});
+	});
+}
+//#endregion
+export { registerAgentCommands };

package/dist/register.configure-FavQPGce.js

@@ -0,0 +1,16 @@
+import { t as formatDocsLink } from "./links-CgdQazeA.js";
+import { r as theme } from "./theme-CLQ2HbnQ.js";
+import { n as runCommandWithRuntime } from "./cli-utils-JYDDzCMN.js";
+import { n as CONFIGURE_WIZARD_SECTIONS } from "./configure.shared-D2zaOGsw.js";
+//#region src/cli/program/register.configure.ts
+function registerConfigureCommand(program) {
+	program.command("configure").description("Interactive configuration for credentials, channels, gateway, and agent defaults").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/configure", "docs.fengming.ai/cli/configure")}\n`).option("--section <section>", `Configuration sections (repeatable). Options: ${CONFIGURE_WIZARD_SECTIONS.join(", ")}`, (value, previous) => [...previous, value], []).action(async (opts) => {
+		const { defaultRuntime } = await import("./runtime-DMT3sBEl.js");
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { configureCommandFromSectionsArg } = await import("./configure.commands-tJzVFJ0o.js");
+			await configureCommandFromSectionsArg(opts.section, defaultRuntime);
+		});
+	});
+}
+//#endregion
+export { registerConfigureCommand };

package/dist/register.crestodian-Cbfmnl6h.js

@@ -0,0 +1,24 @@
+import { r as theme } from "./theme-CLQ2HbnQ.js";
+import { n as defaultRuntime } from "./runtime-BkTkFkXs.js";
+import { t as runCrestodian } from "./crestodian-mXnyuHx9.js";
+import { n as runCommandWithRuntime } from "./cli-utils-JYDDzCMN.js";
+import { t as formatHelpExamples } from "./help-format-CBGqVsX5.js";
+//#region src/cli/program/register.crestodian.ts
+function registerCrestodianCommand(program) {
+	program.command("crestodian").description("Open the ring-zero setup and repair helper").option("-m, --message <text>", "Run one Crestodian request").option("--yes", "Approve persistent config writes for this request", false).option("--json", "Output startup overview as JSON", false).addHelpText("after", () => `\n${theme.heading("Examples:")}\n${formatHelpExamples([
+		["fengming", "Start Crestodian."],
+		["fengming crestodian", "Start Crestodian explicitly."],
+		["fengming crestodian -m \"status\"", "Run one status request."],
+		["fengming crestodian -m \"set default model openai/gpt-5.2\" --yes", "Apply a typed config write."]
+	])}`).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await runCrestodian({
+				message: opts.message,
+				yes: Boolean(opts.yes),
+				json: Boolean(opts.json)
+			});
+		});
+	});
+}
+//#endregion
+export { registerCrestodianCommand };

package/dist/register.maintenance-B8xODEMU.js

@@ -0,0 +1,85 @@
+import { t as formatDocsLink } from "./links-CgdQazeA.js";
+import { r as theme } from "./theme-CLQ2HbnQ.js";
+import { n as defaultRuntime } from "./runtime-BkTkFkXs.js";
+import { n as runCommandWithRuntime } from "./cli-utils-JYDDzCMN.js";
+//#region src/cli/program/register.maintenance.ts
+function registerMaintenanceCommands(program) {
+	program.command("doctor").description("Health checks + quick fixes for the gateway and channels").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/doctor", "docs.fengming.ai/cli/doctor")}\n`).option("--no-workspace-suggestions", "Disable workspace memory system suggestions", false).option("--yes", "Accept defaults without prompting", false).option("--repair", "Apply recommended repairs without prompting", false).option("--fix", "Apply recommended repairs (alias for --repair)", false).option("--force", "Apply aggressive repairs (overwrites custom service config)", false).option("--non-interactive", "Run without prompts (safe migrations only)", false).option("--generate-gateway-token", "Generate and configure a gateway token", false).option("--allow-exec", "Allow doctor to execute exec SecretRefs while verifying configured secrets", false).option("--deep", "Scan system services for extra gateway installs", false).option("--lint", "Run read-only health checks and report findings", false).option("--json", "With --lint: emit JSON findings instead of human output", false).option("--severity-min <level>", "With --lint: drop findings below this severity (info|warning|error)").option("--skip <id>", "With --lint: skip a specific check id (repeatable)", (v, prev) => [...prev, v], []).option("--only <id>", "With --lint: run only the specified check id (repeatable)", (v, prev) => [...prev, v], []).action(async (opts) => {
+		if (opts.lint === true) {
+			await runCommandWithRuntime(defaultRuntime, async () => {
+				const { runDoctorLintCli } = await import("./doctor-lint-BBm6gtBa.js");
+				const exitCode = await runDoctorLintCli(defaultRuntime, {
+					json: Boolean(opts.json),
+					severityMin: typeof opts.severityMin === "string" ? opts.severityMin : void 0,
+					skipIds: Array.isArray(opts.skip) ? opts.skip : [],
+					onlyIds: Array.isArray(opts.only) ? opts.only : [],
+					allowExec: Boolean(opts.allowExec)
+				});
+				defaultRuntime.exit(exitCode);
+			}, (err) => {
+				defaultRuntime.error(String(err));
+				defaultRuntime.exit(2);
+			});
+			return;
+		}
+		if (hasLintOnlyDoctorOptions(opts)) {
+			defaultRuntime.error("doctor lint options require --lint. Use `fengming doctor --lint ...`.");
+			defaultRuntime.exit(2);
+			return;
+		}
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { doctorCommand } = await import("./doctor-gRYfpEbB.js");
+			await doctorCommand(defaultRuntime, {
+				workspaceSuggestions: opts.workspaceSuggestions,
+				yes: Boolean(opts.yes),
+				repair: Boolean(opts.repair) || Boolean(opts.fix),
+				force: Boolean(opts.force),
+				nonInteractive: Boolean(opts.nonInteractive),
+				generateGatewayToken: Boolean(opts.generateGatewayToken),
+				allowExec: Boolean(opts.allowExec),
+				deep: Boolean(opts.deep)
+			});
+			defaultRuntime.exit(0);
+		});
+	});
+	program.command("dashboard").description("Open the Control UI with your current token").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/dashboard", "docs.fengming.ai/cli/dashboard")}\n`).option("--no-open", "Print URL but do not launch a browser").option("--yes", "Start/install the gateway without prompting when needed", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { dashboardCommand } = await import("./dashboard-Ey5dnvMI.js");
+			await dashboardCommand(defaultRuntime, {
+				noOpen: opts.open === false,
+				yes: Boolean(opts.yes)
+			});
+		});
+	});
+	program.command("reset").description("Reset local config/state (keeps the CLI installed)").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/reset", "docs.fengming.ai/cli/reset")}\n`).option("--scope <scope>", "config|config+creds+sessions|full (default: interactive prompt)").option("--yes", "Skip confirmation prompts", false).option("--non-interactive", "Disable prompts (requires --scope + --yes)", false).option("--dry-run", "Print actions without removing files", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { resetCommand } = await import("./reset-LGlHxcRN.js");
+			await resetCommand(defaultRuntime, {
+				scope: opts.scope,
+				yes: Boolean(opts.yes),
+				nonInteractive: Boolean(opts.nonInteractive),
+				dryRun: Boolean(opts.dryRun)
+			});
+		});
+	});
+	program.command("uninstall").description("Uninstall the gateway service + local data (CLI remains)").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/uninstall", "docs.fengming.ai/cli/uninstall")}\n`).option("--service", "Remove the gateway service", false).option("--state", "Remove state + config", false).option("--workspace", "Remove workspace dirs", false).option("--app", "Remove the macOS app", false).option("--all", "Remove service + state + workspace + app", false).option("--yes", "Skip confirmation prompts", false).option("--non-interactive", "Disable prompts (requires --yes)", false).option("--dry-run", "Print actions without removing files", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { uninstallCommand } = await import("./uninstall-D91Jms90.js");
+			await uninstallCommand(defaultRuntime, {
+				service: Boolean(opts.service),
+				state: Boolean(opts.state),
+				workspace: Boolean(opts.workspace),
+				app: Boolean(opts.app),
+				all: Boolean(opts.all),
+				yes: Boolean(opts.yes),
+				nonInteractive: Boolean(opts.nonInteractive),
+				dryRun: Boolean(opts.dryRun)
+			});
+		});
+	});
+}
+function hasLintOnlyDoctorOptions(opts) {
+	return opts.json === true || typeof opts.severityMin === "string" || Array.isArray(opts.skip) && opts.skip.length > 0 || Array.isArray(opts.only) && opts.only.length > 0;
+}
+//#endregion
+export { registerMaintenanceCommands };