fengming 0.3.3 → 0.3.5

package/dist/sessions-DR-X-j8D.js

@@ -0,0 +1,316 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DKw2K5wM.js";
+import { _ as parseStrictPositiveInteger } from "./number-coercion-D1aDmIZp.js";
+import "./parse-finite-number-CpgOyjPq.js";
+import { n as isRich, r as theme } from "./theme-CLQ2HbnQ.js";
+import { t as createLazyImportLoader } from "./lazy-promise-Djskx0qC.js";
+import { r as writeRuntimeJson } from "./runtime-BkTkFkXs.js";
+import { c as parseAgentSessionKey, n as isAcpSessionKey } from "./session-key-utils-CdfsDYvz.js";
+import { n as info } from "./globals-644GLqmc.js";
+import { i as getRuntimeConfig } from "./io-DAZXanmU.js";
+import "./defaults-DNFU4TYx.js";
+import "./config-Dp73zulp.js";
+import { t as loadSessionStore } from "./store-load-Bs35PLbM.js";
+import { t as normalizeChatType } from "./chat-type-DeA3YwAD.js";
+import { l as resolveSessionTotalTokens } from "./types-D7s3-R_6.js";
+import "./sessions-Cs11K_1i.js";
+import { t as resolveModelAgentRuntimeMetadata } from "./agent-runtime-metadata-BhFt6kLt.js";
+import { t as classifySessionKind } from "./classify-session-kind-D7wwfLS1.js";
+import { t as resolveAgentRuntimeLabel } from "./agent-runtime-label-uoFI4ovH.js";
+import { t as resolveRuntimePolicySessionKey } from "./runtime-policy-session-key-CXSRXJ7R.js";
+import { a as toSessionDisplayRow, i as formatSessionModelCell, l as resolveSessionDisplayModelRef, n as formatSessionFlagsCell, r as formatSessionKeyCell, s as resolveSessionDisplayDefaults, t as formatSessionAgeCell, u as resolveSessionStoreTargetsOrExit } from "./sessions-table-Da6bua9d.js";
+//#region src/commands/sessions.ts
+const AGENT_PAD = 10;
+const KIND_PAD = 11;
+const RUNTIME_PAD = 18;
+const TOKENS_PAD = 20;
+const DEFAULT_SESSIONS_LIMIT = 100;
+const TOP_N_SELECTION_LIMIT = 200;
+const contextLookupRuntimeLoader = createLazyImportLoader(() => import("./context-D1N9oPds.js"));
+const formatKTokens = (value) => `${(value / 1e3).toFixed(value >= 1e4 ? 0 : 1)}k`;
+/**
+* Inline ACP model overlay — catalog #20.
+*
+* When a session ran via the ACP control plane (e.g. key =
+* `agent:copilot:acp:<uuid>` AND `entry.acp` is present), the agent's
+* configured model is irrelevant: the actual model is selected inside the ACP
+* child process. We overlay a sentinel `{ provider: "acpx",
+* model: "<agentId>-acp" }` so the listing clearly signals "ACP runtime" and
+* does not mislead operators into thinking the configured model ran.
+*
+* Key-shape alone is not sufficient: ACP bridge sessions (translator.ts) also
+* use ACP-shaped keys but never persist `SessionAcpMeta` — they run the
+* normal configured model and must not receive the sentinel. The `acpRuntime`
+* flag is set at row-construction time from `entry.acp != null`.
+*
+* The resolver (`resolveSessionDisplayModelRef`) stays pure; this overlay
+* applies only at the emit sites in this file.
+*
+* NOTE: Will be replaced by a shared `applyAcpModelOverlay` helper from
+* `src/agents/acp-runtime-overlay.ts` once PR 2 lands.
+*/
+function applyAcpModelOverlayIfNeeded(modelRef, sessionKey, acpRuntime) {
+	if (!acpRuntime || !isAcpSessionKey(sessionKey)) return modelRef;
+	return {
+		provider: "acpx",
+		model: `${parseAgentSessionKey(sessionKey)?.agentId ?? "acp"}-acp`
+	};
+}
+function compareSessionRowsByUpdatedAt(a, b) {
+	return (b.updatedAt ?? 0) - (a.updatedAt ?? 0);
+}
+function selectNewestSessionRows(rows, limit) {
+	if (limit === void 0) return rows.toSorted(compareSessionRowsByUpdatedAt);
+	if (limit > TOP_N_SELECTION_LIMIT) return rows.toSorted(compareSessionRowsByUpdatedAt).slice(0, limit);
+	const selected = [];
+	for (const row of rows) {
+		const insertAt = selected.findIndex((candidate) => compareSessionRowsByUpdatedAt(row, candidate) < 0);
+		if (insertAt >= 0) {
+			selected.splice(insertAt, 0, row);
+			if (selected.length > limit) selected.pop();
+		} else if (selected.length < limit) selected.push(row);
+	}
+	return selected;
+}
+function parseSessionsLimit(value) {
+	if (value === void 0) return DEFAULT_SESSIONS_LIMIT;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (trimmed.toLowerCase() === "all") return;
+		if (!/^\d+$/.test(trimmed)) return null;
+		return parseStrictPositiveInteger(trimmed) ?? null;
+	}
+	return Number.isInteger(value) && value > 0 ? value : null;
+}
+const colorByPct = (label, pct, rich) => {
+	if (!rich || pct === null) return label;
+	if (pct >= 95) return theme.error(label);
+	if (pct >= 80) return theme.warn(label);
+	if (pct >= 60) return theme.success(label);
+	return theme.muted(label);
+};
+const formatTokensCell = (total, contextTokens, rich) => {
+	if (total === void 0) {
+		const label = `unknown/${contextTokens ? formatKTokens(contextTokens) : "?"} (?%)`;
+		return rich ? theme.muted(label.padEnd(TOKENS_PAD)) : label.padEnd(TOKENS_PAD);
+	}
+	const totalLabel = formatKTokens(total);
+	const ctxLabel = contextTokens ? formatKTokens(contextTokens) : "?";
+	const pct = contextTokens ? Math.min(999, Math.round(total / contextTokens * 100)) : null;
+	return colorByPct(`${totalLabel}/${ctxLabel} (${pct ?? "?"}%)`.padEnd(TOKENS_PAD), pct, rich);
+};
+async function lookupContextTokensForDisplay(model) {
+	const { lookupContextTokens } = await contextLookupRuntimeLoader.load();
+	return lookupContextTokens(model, { allowAsyncLoad: false });
+}
+const formatKindCell = (kind, rich) => {
+	const label = kind.padEnd(KIND_PAD);
+	if (!rich) return label;
+	if (kind === "group") return theme.accentBright(label);
+	if (kind === "global") return theme.warn(label);
+	if (kind === "direct") return theme.accent(label);
+	return theme.muted(label);
+};
+function resolveSessionRuntimeLabel(params) {
+	const id = normalizeOptionalLowercaseString(params.agentRuntime.id);
+	const resolvedHarness = id && id !== "fengming" && id !== "auto" ? id : void 0;
+	return resolveAgentRuntimeLabel({
+		config: params.cfg,
+		sessionEntry: params.entry,
+		resolvedHarness,
+		fallbackProvider: params.modelProvider
+	});
+}
+function formatRuntimeCell(runtimeLabel, rich) {
+	const label = runtimeLabel.padEnd(RUNTIME_PAD);
+	return rich ? theme.info(label) : label;
+}
+function toJsonSessionRow(row) {
+	const { runtimeLabel, ...jsonRow } = row;
+	return jsonRow;
+}
+function stripChannelRecipientPrefix(value, channel) {
+	const raw = normalizeOptionalString(value);
+	const normalizedChannel = normalizeOptionalLowercaseString(channel);
+	if (!raw || !normalizedChannel) return raw;
+	const prefix = `${normalizedChannel}:`;
+	if (!raw.toLowerCase().startsWith(prefix)) return raw;
+	const stripped = raw.slice(prefix.length);
+	const topicMarkerIndex = stripped.toLowerCase().indexOf(":topic:");
+	return topicMarkerIndex >= 0 ? stripped.slice(0, topicMarkerIndex) : stripped;
+}
+function resolveDisplayRuntimePolicySessionKey(params) {
+	const { cfg, entry, key } = params;
+	const origin = entry.origin;
+	const deliveryContext = entry.deliveryContext;
+	const chatType = normalizeChatType(origin?.chatType ?? entry.chatType);
+	if (chatType !== "direct") return;
+	const channel = normalizeOptionalString(origin?.provider ?? deliveryContext?.channel ?? entry.lastChannel ?? entry.channel ?? origin?.surface);
+	const to = normalizeOptionalString(origin?.to ?? deliveryContext?.to ?? entry.lastTo);
+	const from = normalizeOptionalString(origin?.from);
+	const nativeDirectUserId = normalizeOptionalString(origin?.nativeDirectUserId);
+	const peerId = nativeDirectUserId ?? stripChannelRecipientPrefix(to, channel) ?? stripChannelRecipientPrefix(from, channel);
+	const runtimePolicySessionKey = resolveRuntimePolicySessionKey({
+		cfg,
+		sessionKey: key,
+		ctx: {
+			SessionKey: key,
+			Provider: channel,
+			Surface: normalizeOptionalString(origin?.surface),
+			AccountId: normalizeOptionalString(origin?.accountId ?? deliveryContext?.accountId ?? entry.lastAccountId),
+			ChatType: chatType,
+			NativeDirectUserId: nativeDirectUserId,
+			SenderId: peerId,
+			OriginatingTo: to,
+			From: from,
+			To: to
+		}
+	});
+	return runtimePolicySessionKey && runtimePolicySessionKey !== key ? runtimePolicySessionKey : void 0;
+}
+async function sessionsCommand(opts, runtime) {
+	const aggregateAgents = opts.allAgents === true;
+	const cfg = getRuntimeConfig();
+	const displayDefaults = resolveSessionDisplayDefaults(cfg);
+	const configuredContextTokens = cfg.agents?.defaults?.contextTokens;
+	const configContextTokens = configuredContextTokens ?? await lookupContextTokensForDisplay(displayDefaults.model) ?? 2e5;
+	const targets = resolveSessionStoreTargetsOrExit({
+		cfg,
+		opts: {
+			store: opts.store,
+			agent: opts.agent,
+			allAgents: opts.allAgents
+		},
+		runtime
+	});
+	if (!targets) return;
+	let activeMinutes;
+	if (opts.active !== void 0) {
+		const parsed = parseStrictPositiveInteger(opts.active);
+		if (parsed === void 0) {
+			runtime.error("--active must be a positive number of minutes, for example --active 30.");
+			runtime.exit(1);
+			return;
+		}
+		activeMinutes = parsed;
+	}
+	const limit = parseSessionsLimit(opts.limit);
+	if (limit === null) {
+		runtime.error("--limit must be a positive integer or \"all\", for example --limit 25.");
+		runtime.exit(1);
+		return;
+	}
+	const allRows = targets.flatMap((target) => {
+		const store = loadSessionStore(target.storePath);
+		return Object.entries(store).filter(([, entry]) => {
+			if (activeMinutes === void 0) return true;
+			const updatedAt = entry?.updatedAt;
+			return typeof updatedAt === "number" && Date.now() - updatedAt <= activeMinutes * 6e4;
+		}).map(([key, entry]) => {
+			const row = toSessionDisplayRow(key, entry);
+			const agentId = parseAgentSessionKey(row.key)?.agentId ?? target.agentId;
+			const acpRuntime = entry?.acp != null;
+			const modelRef = applyAcpModelOverlayIfNeeded(resolveSessionDisplayModelRef(cfg, row), row.key, acpRuntime);
+			const agentRuntime = resolveModelAgentRuntimeMetadata({
+				cfg,
+				agentId,
+				provider: modelRef.provider,
+				model: modelRef.model,
+				sessionKey: row.key,
+				acpRuntime,
+				acpBackend: entry?.acp?.backend
+			});
+			return Object.assign({}, row, {
+				agentId,
+				acpRuntime,
+				agentRuntime,
+				kind: classifySessionKind(row.key, store[row.key]),
+				runtimePolicySessionKey: resolveDisplayRuntimePolicySessionKey({
+					cfg,
+					key: row.key,
+					entry
+				}),
+				runtimeLabel: resolveSessionRuntimeLabel({
+					cfg,
+					entry,
+					agentRuntime,
+					modelProvider: modelRef.provider,
+					model: modelRef.model,
+					agentId,
+					sessionKey: row.key
+				})
+			});
+		});
+	});
+	const totalCount = allRows.length;
+	const rows = selectNewestSessionRows(allRows, limit);
+	const hasMore = rows.length < totalCount;
+	if (opts.json) {
+		const multi = targets.length > 1;
+		const aggregate = aggregateAgents || multi;
+		writeRuntimeJson(runtime, {
+			path: aggregate ? null : targets[0]?.storePath ?? null,
+			stores: aggregate ? targets.map((target) => ({
+				agentId: target.agentId,
+				path: target.storePath
+			})) : void 0,
+			allAgents: aggregateAgents ? true : void 0,
+			count: rows.length,
+			totalCount,
+			limitApplied: limit ?? null,
+			hasMore,
+			activeMinutes: activeMinutes ?? null,
+			sessions: await Promise.all(rows.map(async (row) => {
+				const r = toJsonSessionRow(row);
+				const modelRef = applyAcpModelOverlayIfNeeded(resolveSessionDisplayModelRef(cfg, r), r.key, row.acpRuntime);
+				return {
+					...r,
+					totalTokens: resolveSessionTotalTokens(r) ?? null,
+					totalTokensFresh: typeof r.totalTokens === "number" ? r.totalTokensFresh !== false : false,
+					contextTokens: r.contextTokens ?? configuredContextTokens ?? await lookupContextTokensForDisplay(modelRef.model) ?? configContextTokens ?? null,
+					modelProvider: modelRef.provider,
+					model: modelRef.model
+				};
+			}))
+		});
+		return;
+	}
+	if (targets.length === 1 && !aggregateAgents) runtime.log(info(`Session store: ${targets[0]?.storePath}`));
+	else runtime.log(info(`Session stores: ${targets.length} (${targets.map((t) => t.agentId).join(", ")})`));
+	runtime.log(info(hasMore && limit !== void 0 ? `Sessions listed: ${rows.length} of ${totalCount} (limit ${limit})` : `Sessions listed: ${rows.length}`));
+	if (activeMinutes) runtime.log(info(`Filtered to last ${activeMinutes} minute(s)`));
+	if (rows.length === 0) {
+		runtime.log("No sessions found.");
+		return;
+	}
+	const rich = isRich();
+	const showAgentColumn = aggregateAgents || targets.length > 1;
+	const header = [
+		...showAgentColumn ? ["Agent".padEnd(AGENT_PAD)] : [],
+		"Kind".padEnd(KIND_PAD),
+		"Key".padEnd(26),
+		"Age".padEnd(9),
+		"Model".padEnd(14),
+		"Runtime".padEnd(RUNTIME_PAD),
+		"Tokens (ctx %)".padEnd(TOKENS_PAD),
+		"Flags"
+	].join(" ");
+	runtime.log(rich ? theme.heading(header) : header);
+	for (const row of rows) {
+		const model = applyAcpModelOverlayIfNeeded(resolveSessionDisplayModelRef(cfg, row), row.key, row.acpRuntime).model;
+		const contextTokens = row.contextTokens ?? configuredContextTokens ?? await lookupContextTokensForDisplay(model) ?? configContextTokens;
+		const total = resolveSessionTotalTokens(row);
+		const line = [
+			...showAgentColumn ? [rich ? theme.accentBright(row.agentId.padEnd(AGENT_PAD)) : row.agentId.padEnd(AGENT_PAD)] : [],
+			formatKindCell(row.kind, rich),
+			formatSessionKeyCell(row.key, rich),
+			formatSessionAgeCell(row.updatedAt, rich),
+			formatSessionModelCell(model, rich),
+			formatRuntimeCell(row.runtimeLabel, rich),
+			formatTokensCell(total, contextTokens ?? null, rich),
+			formatSessionFlagsCell(row, rich)
+		].join(" ");
+		runtime.log(line.trimEnd());
+	}
+}
+//#endregion
+export { sessionsCommand };

package/dist/sessions-cleanup-CR1CFcJb.js

@@ -0,0 +1,165 @@
+import { n as isRich, r as theme } from "./theme-CLQ2HbnQ.js";
+import { r as writeRuntimeJson } from "./runtime-BkTkFkXs.js";
+import { i as getRuntimeConfig } from "./io-DAZXanmU.js";
+import "./config-Dp73zulp.js";
+import { i as GATEWAY_CLIENT_NAMES, r as GATEWAY_CLIENT_MODES } from "./client-info-D6_UASoA.js";
+import "./message-channel-DcN_7tYD.js";
+import { d as isGatewayTransportError, i as callGateway } from "./call-DJp3MXHX.js";
+import { i as serializeSessionCleanupResult, n as resolveSessionCleanupAction, r as runSessionsCleanup } from "./sessions-Cs11K_1i.js";
+import { c as resolveSessionDisplayModel, i as formatSessionModelCell, n as formatSessionFlagsCell, o as toSessionDisplayRows, r as formatSessionKeyCell, t as formatSessionAgeCell, u as resolveSessionStoreTargetsOrExit } from "./sessions-table-Da6bua9d.js";
+//#region src/commands/sessions-cleanup.ts
+const ACTION_PAD = 16;
+function formatCleanupActionCell(action, rich) {
+	const label = action.padEnd(ACTION_PAD);
+	if (!rich) return label;
+	if (action === "keep") return theme.muted(label);
+	if (action === "prune-missing") return theme.error(label);
+	if (action === "prune-stale") return theme.warn(label);
+	if (action === "retire-dm-scope") return theme.warn(label);
+	if (action === "cap-overflow") return theme.accentBright(label);
+	return theme.error(label);
+}
+function buildActionRows(params) {
+	return toSessionDisplayRows(params.beforeStore).map((row) => Object.assign({}, row, { action: resolveSessionCleanupAction({
+		key: row.key,
+		missingKeys: params.missingKeys,
+		staleKeys: params.staleKeys,
+		cappedKeys: params.cappedKeys,
+		budgetEvictedKeys: params.budgetEvictedKeys,
+		dmScopeRetiredKeys: params.dmScopeRetiredKeys
+	}) }));
+}
+function renderStoreDryRunPlan(params) {
+	const rich = isRich();
+	if (params.showAgentHeader) params.runtime.log(`Agent: ${params.summary.agentId}`);
+	params.runtime.log(`Session store: ${params.summary.storePath}`);
+	params.runtime.log(`Maintenance mode: ${params.summary.mode}`);
+	params.runtime.log(`Entries: ${params.summary.beforeCount} -> ${params.summary.afterCount} (remove ${params.summary.beforeCount - params.summary.afterCount})`);
+	params.runtime.log(`Would prune missing transcripts: ${params.summary.missing}`);
+	params.runtime.log(`Would retire stale direct DM sessions: ${params.summary.dmScopeRetired}`);
+	params.runtime.log(`Would prune stale: ${params.summary.pruned}`);
+	params.runtime.log(`Would cap overflow: ${params.summary.capped}`);
+	if (params.summary.unreferencedArtifacts?.scannedFiles) params.runtime.log(`Would prune unreferenced artifacts: ${params.summary.unreferencedArtifacts.removedFiles}`);
+	if (params.summary.diskBudget) params.runtime.log(`Would enforce disk budget: ${params.summary.diskBudget.totalBytesBefore} -> ${params.summary.diskBudget.totalBytesAfter} bytes (files ${params.summary.diskBudget.removedFiles}, entries ${params.summary.diskBudget.removedEntries})`);
+	if (params.actionRows.length === 0) return;
+	params.runtime.log("");
+	params.runtime.log("Planned session actions:");
+	const header = [
+		"Action".padEnd(ACTION_PAD),
+		"Key".padEnd(26),
+		"Age".padEnd(9),
+		"Model".padEnd(14),
+		"Flags"
+	].join(" ");
+	params.runtime.log(rich ? theme.heading(header) : header);
+	for (const actionRow of params.actionRows) {
+		const model = resolveSessionDisplayModel(params.cfg, actionRow);
+		const line = [
+			formatCleanupActionCell(actionRow.action, rich),
+			formatSessionKeyCell(actionRow.key, rich),
+			formatSessionAgeCell(actionRow.updatedAt, rich),
+			formatSessionModelCell(model, rich),
+			formatSessionFlagsCell(actionRow, rich)
+		].join(" ");
+		params.runtime.log(line.trimEnd());
+	}
+}
+function renderAppliedSummaries(params) {
+	for (let i = 0; i < params.summaries.length; i += 1) {
+		const summary = params.summaries[i];
+		if (!summary) continue;
+		if (i > 0) params.runtime.log("");
+		if (params.summaries.length > 1) params.runtime.log(`Agent: ${summary.agentId}`);
+		params.runtime.log(`Session store: ${summary.storePath}`);
+		params.runtime.log(`Applied maintenance. Current entries: ${summary.appliedCount ?? 0}`);
+		if (summary.unreferencedArtifacts?.removedFiles) params.runtime.log(`Pruned unreferenced artifacts: ${summary.unreferencedArtifacts.removedFiles}`);
+	}
+}
+async function maybeRunGatewayCleanup(opts) {
+	if (opts.store || opts.dryRun) return null;
+	try {
+		return await callGateway({
+			method: "sessions.cleanup",
+			params: {
+				agent: opts.agent,
+				allAgents: opts.allAgents,
+				enforce: opts.enforce,
+				activeKey: opts.activeKey,
+				fixMissing: opts.fixMissing,
+				fixDmScope: opts.fixDmScope
+			},
+			mode: GATEWAY_CLIENT_MODES.CLI,
+			clientName: GATEWAY_CLIENT_NAMES.CLI,
+			requiredMethods: ["sessions.cleanup"]
+		});
+	} catch (error) {
+		if (isGatewayTransportError(error)) return null;
+		throw error;
+	}
+}
+async function sessionsCleanupCommand(opts, runtime) {
+	const gatewayResult = await maybeRunGatewayCleanup(opts);
+	if (gatewayResult) {
+		if (opts.json) {
+			writeRuntimeJson(runtime, gatewayResult);
+			return;
+		}
+		renderAppliedSummaries({
+			summaries: "stores" in gatewayResult ? gatewayResult.stores : [gatewayResult],
+			runtime
+		});
+		return;
+	}
+	const cfg = getRuntimeConfig();
+	const targets = resolveSessionStoreTargetsOrExit({
+		cfg,
+		opts: {
+			store: opts.store,
+			agent: opts.agent,
+			allAgents: opts.allAgents
+		},
+		runtime
+	});
+	if (!targets) return;
+	const { mode, previewResults, appliedSummaries } = await runSessionsCleanup({
+		cfg,
+		opts,
+		targets
+	});
+	if (opts.dryRun) {
+		if (opts.json) {
+			writeRuntimeJson(runtime, serializeSessionCleanupResult({
+				mode,
+				dryRun: true,
+				summaries: previewResults.map((result) => result.summary)
+			}));
+			return;
+		}
+		for (let i = 0; i < previewResults.length; i += 1) {
+			const result = previewResults[i];
+			if (i > 0) runtime.log("");
+			renderStoreDryRunPlan({
+				cfg,
+				summary: result.summary,
+				actionRows: buildActionRows(result),
+				runtime,
+				showAgentHeader: previewResults.length > 1
+			});
+		}
+		return;
+	}
+	if (opts.json) {
+		writeRuntimeJson(runtime, serializeSessionCleanupResult({
+			mode,
+			dryRun: false,
+			summaries: appliedSummaries
+		}));
+		return;
+	}
+	renderAppliedSummaries({
+		summaries: appliedSummaries,
+		runtime
+	});
+}
+//#endregion
+export { sessionsCleanupCommand };