fengming 0.3.7 → 0.3.9

package/dist/assistant-v5fdOYu7.js

@@ -1,291 +0,0 @@
-import "./agent-scope-EEbMCF2I.js";
-import { c as resolveDefaultAgentId } from "./agent-scope-config-BHdZonI2.js";
-import { u as readConfigFileSnapshot } from "./io-T1CV3Z1L.js";
-import "./config-4B-JCqw_.js";
-import { n as extractAssistantText } from "./embedded-agent-utils-CFR2b0P2.js";
-import { r as prepareSimpleCompletionModelForAgent, t as completeWithPreparedSimpleCompletionModel } from "./simple-completion-runtime-D9ketq_T.js";
-import path from "node:path";
-import fs from "node:fs/promises";
-import os from "node:os";
-import { randomUUID } from "node:crypto";
-//#region src/crestodian/assistant-backends.ts
-const CRESTODIAN_CLAUDE_CLI_MODEL = "claude-opus-4-8";
-const CRESTODIAN_CODEX_MODEL = "gpt-5.5";
-const CLAUDE_CLI_BACKEND = {
-	kind: "claude-cli",
-	label: `claude-cli/${CRESTODIAN_CLAUDE_CLI_MODEL}`,
-	runner: "cli",
-	provider: "claude-cli",
-	model: CRESTODIAN_CLAUDE_CLI_MODEL,
-	buildConfig: (workspaceDir) => buildCliPlannerConfig(workspaceDir, `claude-cli/${CRESTODIAN_CLAUDE_CLI_MODEL}`)
-};
-const CODEX_APP_SERVER_BACKEND = {
-	kind: "codex-app-server",
-	label: `openai/${CRESTODIAN_CODEX_MODEL} via codex`,
-	runner: "embedded",
-	provider: "openai",
-	model: CRESTODIAN_CODEX_MODEL,
-	buildConfig: buildCodexAppServerPlannerConfig
-};
-function selectCrestodianLocalPlannerBackends(overview) {
-	const backends = [];
-	if (overview.tools.claude.found) backends.push(CLAUDE_CLI_BACKEND);
-	if (overview.tools.codex.found) backends.push(CODEX_APP_SERVER_BACKEND);
-	return backends;
-}
-function buildCliPlannerConfig(workspaceDir, modelRef) {
-	return { agents: { defaults: {
-		workspace: workspaceDir,
-		model: { primary: modelRef }
-	} } };
-}
-function buildCodexAppServerPlannerConfig(workspaceDir) {
-	return {
-		agents: { defaults: {
-			workspace: workspaceDir,
-			model: { primary: `openai/${CRESTODIAN_CODEX_MODEL}` }
-		} },
-		plugins: { entries: { codex: { enabled: true } } }
-	};
-}
-//#endregion
-//#region src/crestodian/assistant-prompts.ts
-const CRESTODIAN_ASSISTANT_TIMEOUT_MS = 1e4;
-const CRESTODIAN_ASSISTANT_SYSTEM_PROMPT = [
-	"You are Crestodian, FengMing's ring-zero setup helper.",
-	"Turn the user's request into exactly one safe FengMing Crestodian command.",
-	"Return only compact JSON with keys reply and command.",
-	"Do not invent commands. Do not claim a write was applied.",
-	"Do not use tools, shell commands, file edits, or network lookups; plan only from the supplied overview.",
-	"Use the provided FengMing docs/source references when the user's request needs behavior, config, or architecture details.",
-	"If local source is available, prefer inspecting it. Otherwise point to GitHub and strongly recommend reviewing source when docs are not enough.",
-	"Allowed commands:",
-	"- setup",
-	"- status",
-	"- health",
-	"- doctor",
-	"- doctor fix",
-	"- gateway status",
-	"- restart gateway",
-	"- start gateway",
-	"- stop gateway",
-	"- agents",
-	"- models",
-	"- plugins list",
-	"- plugins search <query>",
-	"- plugin install <npm-or-clawhub-spec>",
-	"- plugin uninstall <id>",
-	"- audit",
-	"- validate config",
-	"- set default model <provider/model>",
-	"- config set <path> <value>",
-	"- config set-ref <path> env <ENV_VAR>",
-	"- create agent <id> workspace <path> model <provider/model>",
-	"- talk to <id> agent",
-	"- talk to agent",
-	"If unsure, choose overview."
-].join("\n");
-function buildCrestodianAssistantUserPrompt(params) {
-	const agents = params.overview.agents.map((agent) => {
-		return `- ${[
-			`id=${agent.id}`,
-			agent.name ? `name=${agent.name}` : void 0,
-			agent.workspace ? `workspace=${agent.workspace}` : void 0,
-			agent.model ? `model=${agent.model}` : void 0,
-			agent.isDefault ? "default=true" : void 0
-		].filter(Boolean).join(", ")}`;
-	}).join("\n");
-	return [
-		`User request: ${params.input}`,
-		"",
-		`Default agent: ${params.overview.defaultAgentId}`,
-		`Default model: ${params.overview.defaultModel ?? "not configured"}`,
-		`Config valid: ${params.overview.config.valid}`,
-		`Gateway reachable: ${params.overview.gateway.reachable}`,
-		`Codex binary: ${params.overview.tools.codex.found ? "found" : "not found"}`,
-		`Claude Code CLI: ${params.overview.tools.claude.found ? "found" : "not found"}`,
-		`OpenAI API key: ${params.overview.tools.apiKeys.openai ? "found" : "not found"}`,
-		`Anthropic API key: ${params.overview.tools.apiKeys.anthropic ? "found" : "not found"}`,
-		`FengMing docs: ${params.overview.references.docsPath ?? params.overview.references.docsUrl}`,
-		`FengMing source: ${params.overview.references.sourcePath ?? params.overview.references.sourceUrl}`,
-		params.overview.references.sourcePath ? "Source mode: local git checkout; inspect source directly when docs are insufficient." : "Source mode: package/install; use GitHub source when docs are insufficient.",
-		"",
-		"Agents:",
-		agents || "- none"
-	].join("\n");
-}
-function parseCrestodianAssistantPlanText(rawText) {
-	const text = rawText?.trim();
-	if (!text) return null;
-	const jsonText = extractFirstJsonObject(text);
-	if (!jsonText) return null;
-	let parsed;
-	try {
-		parsed = JSON.parse(jsonText);
-	} catch {
-		return null;
-	}
-	if (!parsed || typeof parsed !== "object") return null;
-	const record = parsed;
-	const command = typeof record.command === "string" ? record.command.trim() : "";
-	if (!command) return null;
-	const reply = typeof record.reply === "string" ? record.reply.trim() : void 0;
-	return {
-		command,
-		...reply ? { reply } : {}
-	};
-}
-function extractFirstJsonObject(text) {
-	const start = text.indexOf("{");
-	const end = text.lastIndexOf("}");
-	if (start < 0 || end <= start) return null;
-	return text.slice(start, end + 1);
-}
-//#endregion
-//#region src/crestodian/assistant.ts
-async function planCrestodianCommand(params) {
-	const configured = await planCrestodianCommandWithConfiguredModel(params);
-	if (configured) return configured;
-	return await planCrestodianCommandWithLocalRuntime(params);
-}
-async function planCrestodianCommandWithConfiguredModel(params) {
-	const input = params.input.trim();
-	if (!input) return null;
-	const snapshot = await (params.deps?.readConfigFileSnapshot ?? readConfigFileSnapshot)();
-	if (!snapshot.exists || !snapshot.valid) return null;
-	const cfg = snapshot.runtimeConfig ?? snapshot.config;
-	const agentId = resolveDefaultAgentId(cfg);
-	const prepared = await (params.deps?.prepareSimpleCompletionModelForAgent ?? prepareSimpleCompletionModelForAgent)({
-		cfg,
-		agentId,
-		allowMissingApiKeyModes: ["aws-sdk"]
-	});
-	if ("error" in prepared) return null;
-	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), CRESTODIAN_ASSISTANT_TIMEOUT_MS);
-	try {
-		const parsed = parseCrestodianAssistantPlanText(extractAssistantText(await (params.deps?.completeWithPreparedSimpleCompletionModel ?? completeWithPreparedSimpleCompletionModel)({
-			model: prepared.model,
-			auth: prepared.auth,
-			context: {
-				systemPrompt: CRESTODIAN_ASSISTANT_SYSTEM_PROMPT,
-				messages: [{
-					role: "user",
-					content: buildCrestodianAssistantUserPrompt({
-						input,
-						overview: params.overview
-					}),
-					timestamp: Date.now()
-				}]
-			},
-			options: {
-				maxTokens: 512,
-				signal: controller.signal
-			}
-		})));
-		if (!parsed) return null;
-		return {
-			...parsed,
-			modelLabel: `${prepared.selection.provider}/${prepared.selection.modelId}`
-		};
-	} catch {
-		return null;
-	} finally {
-		clearTimeout(timer);
-	}
-}
-async function planCrestodianCommandWithLocalRuntime(params) {
-	const input = params.input.trim();
-	if (!input) return null;
-	const backends = selectCrestodianLocalPlannerBackends(params.overview);
-	if (backends.length === 0) return null;
-	const prompt = buildCrestodianAssistantUserPrompt({
-		input,
-		overview: params.overview
-	});
-	for (const backend of backends) try {
-		const parsed = parseCrestodianAssistantPlanText(await runLocalRuntimePlanner(backend, {
-			prompt,
-			deps: params.deps
-		}));
-		if (parsed) return {
-			...parsed,
-			modelLabel: backend.label
-		};
-	} catch {}
-	return null;
-}
-async function runLocalRuntimePlanner(backend, params) {
-	const tempDir = await (params.deps?.createTempDir ?? createTempPlannerDir)();
-	try {
-		const runId = `crestodian-planner-${randomUUID()}`;
-		const sessionFile = path.join(tempDir, "session.jsonl");
-		const sessionId = `${runId}-session`;
-		const sessionKey = `temp:crestodian-planner:${runId}`;
-		switch (backend.runner) {
-			case "cli": return extractPlannerResultText(await (params.deps?.runCliAgent ?? await loadRunCliAgent())({
-				sessionId,
-				sessionKey,
-				agentId: "crestodian",
-				trigger: "manual",
-				sessionFile,
-				workspaceDir: tempDir,
-				config: backend.buildConfig(tempDir),
-				prompt: params.prompt,
-				provider: backend.provider,
-				model: backend.model,
-				timeoutMs: CRESTODIAN_ASSISTANT_TIMEOUT_MS,
-				runId,
-				extraSystemPrompt: CRESTODIAN_ASSISTANT_SYSTEM_PROMPT,
-				extraSystemPromptStatic: CRESTODIAN_ASSISTANT_SYSTEM_PROMPT,
-				messageChannel: "crestodian",
-				messageProvider: "crestodian",
-				cleanupCliLiveSessionOnRunEnd: true
-			}));
-			case "embedded": return extractPlannerResultText(await (params.deps?.runEmbeddedAgent ?? await loadRunEmbeddedAgent())({
-				sessionId,
-				sessionKey,
-				agentId: "crestodian",
-				trigger: "manual",
-				sessionFile,
-				workspaceDir: tempDir,
-				config: backend.buildConfig(tempDir),
-				prompt: params.prompt,
-				provider: backend.provider,
-				model: backend.model,
-				agentHarnessId: "codex",
-				disableTools: true,
-				toolsAllow: [],
-				timeoutMs: CRESTODIAN_ASSISTANT_TIMEOUT_MS,
-				runId,
-				extraSystemPrompt: CRESTODIAN_ASSISTANT_SYSTEM_PROMPT,
-				messageChannel: "crestodian",
-				messageProvider: "crestodian",
-				cleanupBundleMcpOnRunEnd: true
-			}));
-		}
-		return;
-	} finally {
-		await (params.deps?.removeTempDir ?? removeTempPlannerDir)(tempDir);
-	}
-}
-async function createTempPlannerDir() {
-	return await fs.mkdtemp(path.join(os.tmpdir(), "fengming-crestodian-planner-"));
-}
-async function removeTempPlannerDir(dir) {
-	await fs.rm(dir, {
-		recursive: true,
-		force: true
-	});
-}
-async function loadRunCliAgent() {
-	return (await import("./cli-runner-DO4SORQf.js")).runCliAgent;
-}
-async function loadRunEmbeddedAgent() {
-	return (await import("./embedded-agent-NEmNlXDR.js")).runEmbeddedAgent;
-}
-function extractPlannerResultText(result) {
-	return result.meta?.finalAssistantVisibleText ?? result.meta?.finalAssistantRawText ?? result.payloads?.map((payload) => payload.text?.trim()).filter(Boolean).join("\n");
-}
-//#endregion
-export { planCrestodianCommand };

package/dist/attachment-normalize-BHAbLiL2.js

@@ -1,213 +0,0 @@
-import { s as normalizeOptionalLowercaseString } from "./string-coerce-DKw2K5wM.js";
-import { i as formatErrorMessage } from "./errors-C_Wa6a5T.js";
-import { r as MAX_IMAGE_BYTES } from "./constants-D9zVCSKe.js";
-import { l as mimeTypeFromFilePath, r as extensionForMime } from "./mime-TnUOZVhx.js";
-import { w as sniffMimeFromBase64 } from "./fengming-tools-gQkwsWYz.js";
-import { n as estimateBase64DecodedBytes } from "./base64-D03BM6T6.js";
-import { i as deleteMediaBuffer, u as saveMediaBuffer } from "./store-BCRjjjf9.js";
-//#region src/gateway/chat-attachments.ts
-const OFFLOAD_THRESHOLD_BYTES = 2e6;
-const TEXT_ONLY_OFFLOAD_LIMIT = 10;
-function resolveChatAttachmentMaxBytes(cfg) {
-	const configured = cfg.agents?.defaults?.mediaMaxMb;
-	return Math.floor((typeof configured === "number" && Number.isFinite(configured) && configured > 0 ? configured : 20) * 1024 * 1024);
-}
-var UnsupportedAttachmentError = class extends Error {
-	constructor(reason, message) {
-		super(message);
-		this.name = "UnsupportedAttachmentError";
-		this.reason = reason;
-	}
-};
-var MediaOffloadError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "MediaOffloadError";
-		this.cause = options?.cause;
-	}
-};
-function normalizeMime(mime) {
-	if (!mime) return;
-	return normalizeOptionalLowercaseString(mime.split(";")[0]) || void 0;
-}
-function isImageMime(mime) {
-	return typeof mime === "string" && mime.startsWith("image/");
-}
-function isGenericContainerMime(mime) {
-	return mime === "application/zip" || mime === "application/octet-stream";
-}
-function shouldIgnoreImageMimeHint(params) {
-	return isGenericContainerMime(params.sniffedMime) && isImageMime(params.hintedMime);
-}
-function isSpecificMime(mime) {
-	return Boolean(mime && !isGenericContainerMime(mime));
-}
-function resolveAttachmentMime(params) {
-	const trustedProvidedMime = shouldIgnoreImageMimeHint({
-		sniffedMime: params.sniffedMime,
-		hintedMime: params.providedMime
-	}) ? void 0 : params.providedMime;
-	const trustedLabelMime = shouldIgnoreImageMimeHint({
-		sniffedMime: params.sniffedMime,
-		hintedMime: params.labelMime
-	}) ? void 0 : params.labelMime;
-	return isSpecificMime(params.sniffedMime) && params.sniffedMime || isSpecificMime(trustedProvidedMime) && trustedProvidedMime || isSpecificMime(trustedLabelMime) && trustedLabelMime || params.sniffedMime || trustedProvidedMime || trustedLabelMime || "application/octet-stream";
-}
-function isValidBase64(value) {
-	if (value.length === 0 || value.length % 4 !== 0) return false;
-	return /^[A-Za-z0-9+/]+={0,2}$/.test(value);
-}
-function verifyDecodedSize(buffer, estimatedBytes, label) {
-	if (Math.abs(buffer.byteLength - estimatedBytes) > 3) throw new Error(`attachment ${label}: base64 contains invalid characters (expected ~${estimatedBytes} bytes decoded, got ${buffer.byteLength})`);
-}
-function ensureExtension(label, mime) {
-	if (/\.[a-zA-Z0-9]+$/.test(label)) return label;
-	const ext = extensionForMime(mime) ?? "";
-	return ext ? `${label}${ext}` : label;
-}
-function assertSavedMedia(value, label) {
-	if (value === null || typeof value !== "object" || !("id" in value) || typeof value.id !== "string") throw new Error(`attachment ${label}: saveMediaBuffer returned an unexpected shape`);
-	const id = value.id;
-	if (id.length === 0) throw new Error(`attachment ${label}: saveMediaBuffer returned an empty media ID`);
-	if (id.includes("/") || id.includes("\\") || id.includes("\0")) throw new Error(`attachment ${label}: saveMediaBuffer returned an unsafe media ID (contains path separator or null byte)`);
-	const path = value.path;
-	if (typeof path !== "string" || path.length === 0) throw new Error(`attachment ${label}: saveMediaBuffer returned no on-disk path`);
-	return {
-		id,
-		path
-	};
-}
-function normalizeAttachment(att, idx, opts) {
-	const mime = att.mimeType ?? "";
-	const content = att.content;
-	const label = att.fileName || att.type || `attachment-${idx + 1}`;
-	if (typeof content !== "string") throw new Error(`attachment ${label}: content must be base64 string`);
-	if (opts.requireImageMime && !mime.startsWith("image/")) throw new Error(`attachment ${label}: only image/* supported`);
-	let base64 = content.trim();
-	if (opts.stripDataUrlPrefix) {
-		const dataUrlMatch = /^data:[^;]+;base64,(.*)$/.exec(base64);
-		if (dataUrlMatch) base64 = dataUrlMatch[1];
-	}
-	return {
-		label,
-		mime,
-		base64
-	};
-}
-async function parseMessageWithAttachments(message, attachments, opts) {
-	const maxBytes = opts?.maxBytes ?? 20 * 1024 * 1024;
-	const log = opts?.log;
-	const shouldForceImageOffload = opts?.supportsImages === false;
-	const supportsInlineImages = opts?.supportsInlineImages !== false;
-	const acceptNonImage = opts?.acceptNonImage !== false;
-	if (!attachments || attachments.length === 0) return {
-		message,
-		images: [],
-		imageOrder: [],
-		offloadedRefs: []
-	};
-	const images = [];
-	const imageOrder = [];
-	const offloadedRefs = [];
-	let updatedMessage = message;
-	let textOnlyImageOffloadCount = 0;
-	const savedMediaIds = [];
-	try {
-		for (const [idx, att] of attachments.entries()) {
-			if (!att) continue;
-			const { base64: b64, label, mime } = normalizeAttachment(att, idx, {
-				stripDataUrlPrefix: true,
-				requireImageMime: false
-			});
-			if (b64.length === 0) throw new UnsupportedAttachmentError("empty-payload", `attachment ${label}: empty payload`);
-			if (!isValidBase64(b64)) throw new Error(`attachment ${label}: invalid base64 content`);
-			const sizeBytes = estimateBase64DecodedBytes(b64);
-			if (sizeBytes > maxBytes) throw new Error(`attachment ${label}: exceeds size limit (${sizeBytes} > ${maxBytes} bytes)`);
-			const providedMime = normalizeMime(mime);
-			const sniffedMime = normalizeMime(await sniffMimeFromBase64(b64));
-			const finalMime = resolveAttachmentMime({
-				sniffedMime,
-				providedMime,
-				labelMime: normalizeMime(mimeTypeFromFilePath(label))
-			});
-			if (sniffedMime && providedMime && !isGenericContainerMime(providedMime) && sniffedMime !== providedMime) {
-				const usedSource = finalMime === sniffedMime ? "sniffed" : finalMime === providedMime ? "provided" : "label-derived";
-				log?.warn(`attachment ${label}: mime mismatch (${providedMime} -> ${sniffedMime}), using ${usedSource}`);
-			}
-			const isImage = isImageMime(finalMime);
-			if (isImage && !supportsInlineImages && !shouldForceImageOffload) throw new UnsupportedAttachmentError("text-only-image", `attachment ${label}: active model does not accept image inputs`);
-			if (!isImage && !acceptNonImage) throw new UnsupportedAttachmentError("unsupported-non-image", `attachment ${label}: non-image attachments (${finalMime}) are not supported on this entrypoint`);
-			if (isImage && sizeBytes > 6291456) throw new Error(`attachment ${label}: image exceeds size limit (${sizeBytes} > ${MAX_IMAGE_BYTES} bytes)`);
-			if (shouldForceImageOffload && isImage && textOnlyImageOffloadCount >= TEXT_ONLY_OFFLOAD_LIMIT) {
-				log?.warn(`attachment ${label}: dropping image because text-only offload limit ${TEXT_ONLY_OFFLOAD_LIMIT} was reached`);
-				updatedMessage += "\n[image attachment omitted: text-only attachment limit reached]";
-				continue;
-			}
-			if (!(shouldForceImageOffload || !isImage || sizeBytes > OFFLOAD_THRESHOLD_BYTES)) {
-				images.push({
-					type: "image",
-					data: b64,
-					mimeType: finalMime
-				});
-				imageOrder.push("inline");
-				continue;
-			}
-			const buffer = Buffer.from(b64, "base64");
-			verifyDecodedSize(buffer, sizeBytes, label);
-			let savedMedia;
-			try {
-				savedMedia = assertSavedMedia(await saveMediaBuffer(buffer, finalMime, "inbound", maxBytes, ensureExtension(label, finalMime)), label);
-			} catch (err) {
-				throw new MediaOffloadError(`[Gateway Error] Failed to save intercepted media to disk: ${formatErrorMessage(err)}`, { cause: err });
-			}
-			savedMediaIds.push(savedMedia.id);
-			const mediaRef = `media://inbound/${savedMedia.id}`;
-			if (isImage) updatedMessage += `\n[media attached: ${mediaRef}]`;
-			log?.info?.(shouldForceImageOffload && isImage ? `[Gateway] Offloaded image for text-only model. Saved: ${mediaRef}` : `[Gateway] Offloaded attachment (${finalMime}). Saved: ${mediaRef}`);
-			offloadedRefs.push({
-				mediaRef,
-				id: savedMedia.id,
-				path: savedMedia.path,
-				mimeType: finalMime,
-				label,
-				sizeBytes
-			});
-			if (isImage) {
-				imageOrder.push("offloaded");
-				if (shouldForceImageOffload) textOnlyImageOffloadCount++;
-			}
-		}
-	} catch (err) {
-		if (savedMediaIds.length > 0) await Promise.allSettled(savedMediaIds.map((id) => deleteMediaBuffer(id, "inbound")));
-		throw err;
-	}
-	return {
-		message: updatedMessage !== message ? updatedMessage.trimEnd() : message,
-		images,
-		imageOrder,
-		offloadedRefs
-	};
-}
-//#endregion
-//#region src/gateway/server-methods/attachment-normalize.ts
-function normalizeAttachmentContent(content) {
-	if (typeof content === "string") return content;
-	if (ArrayBuffer.isView(content)) return Buffer.from(content.buffer, content.byteOffset, content.byteLength).toString("base64");
-	if (content instanceof ArrayBuffer) return Buffer.from(content).toString("base64");
-}
-function normalizeRpcAttachmentsToChatAttachments(attachments) {
-	return attachments?.map((a) => {
-		const sourceRecord = a?.source && typeof a.source === "object" ? a.source : void 0;
-		const sourceType = typeof sourceRecord?.type === "string" ? sourceRecord.type : void 0;
-		const sourceMimeType = typeof sourceRecord?.media_type === "string" ? sourceRecord.media_type : void 0;
-		const sourceContent = sourceType === "base64" ? normalizeAttachmentContent(sourceRecord?.data) : void 0;
-		return {
-			type: typeof a?.type === "string" ? a.type : void 0,
-			mimeType: typeof a?.mimeType === "string" ? a.mimeType : sourceMimeType,
-			fileName: typeof a?.fileName === "string" ? a.fileName : void 0,
-			content: normalizeAttachmentContent(a?.content) ?? sourceContent
-		};
-	}).filter((a) => a.content) ?? [];
-}
-//#endregion
-export { resolveChatAttachmentMaxBytes as a, parseMessageWithAttachments as i, MediaOffloadError as n, UnsupportedAttachmentError as r, normalizeRpcAttachmentsToChatAttachments as t };