@klarkxy/dsh-deep-view 0.0.0-stage → 0.2.0

package/lib/index.js

@@ -0,0 +1,1153 @@
+import { _ as viewSummary, i as checkShownView, p as validateViewAnswer } from "./core2.js";
+import { HOST_SERVICE, PLUGIN_NAME, RPC_CHANNEL, VIEW_OWNER, isRecord } from "./contracts.js";
+import { answerText } from "./answer-text.js";
+import { randomUUID } from "node:crypto";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { appendFileSync, existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region ../dsh-plugin-kit/src/log-shared.ts
+const PLUGIN_LOG_LEVELS = [
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fault"
+];
+const DEFAULT_PLUGIN_LOG_LEVEL = "info";
+const PLUGIN_LOG_MAX_MESSAGE_CHARS = 16e3;
+const SOURCE_RE = /^[a-z][a-z0-9-]{0,63}$/;
+const EVENT_RE = /^[a-z][a-z0-9._-]{0,127}$/;
+const CONTEXT_KEY_RE = /^[a-zA-Z][a-zA-Z0-9._-]{0,63}$/;
+const SECRET_KEY_RE = /(?:api[_-]?key|access[_-]?token|refresh[_-]?token|bearer|authorization|cookie|set[_-]?cookie|nonce|credential|private[_-]?key|password|secret|app[_-]?secret|client[_-]?secret|z_c0|d_c0)$/i;
+const CHAT_PAYLOAD_RE = /"role"\s*:\s*"(?:system|user|assistant|tool)"|"(?:messages|content|prompt|input_text|input_image|image_url)"\s*:\s*[\[{"']/i;
+const CREDENTIAL_BODY_RE = /-----BEGIN (?:RSA |EC |OPENSSH |PRIVATE )?PRIVATE KEY-----|"type"\s*:\s*"service_account"|credentials\.json|\.dsh[/\\](?:credentials|auth)/i;
+const AUTH_HEADER_RE = /\b(Authorization|Proxy-Authorization|Cookie|Set-Cookie)\s*:\s*[^\r\n]*/gi;
+const BEARER_RE = /\bBearer\s+[A-Za-z0-9._\-+=/]{8,}/g;
+const SECRET_FIELD_RE = /(["']?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|bearer|authorization|cookie|set-cookie|nonce|credential|private[_-]?key|password|secret|app[_-]?secret|client[_-]?secret|password|z_c0|d_c0)["']?\s*[:=]\s*)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,&;}]+)/gi;
+const SECRET_QUERY_RE = /([?&](?:token|api[_-]?key|key|secret|password|bootstrap|code|sig|signature|credential|password)=)[^\s&#"']+/gi;
+const URL_CREDENTIAL_RE = /\b(https?:\/\/)[^\s/:@]+:[^\s/@]+@/gi;
+const BOOTSTRAP_RE = /\/bootstrap\/[^\s"'?&#]+/gi;
+const KNOWN_TOKEN_RE = /\b(?:sk-[A-Za-z0-9_-]{10,}|gh[pousr]_[A-Za-z0-9_]{16,}|github_pat_[A-Za-z0-9_]{20,}|tvly-[A-Za-z0-9_-]{10,}|AKIA[0-9A-Z]{16})\b/g;
+const PATH_RE = /(?:[A-Za-z]:\\|\\\\)[^\s"'`<>|]+|(?:\/(?:home|Users|tmp|var|root)\/|~\/)[^\s"'`<>|]+/g;
+function isPluginLogLevel(value) {
+	return typeof value === "string" && PLUGIN_LOG_LEVELS.includes(value);
+}
+function pluginLogLevelEnabled(level, minimum) {
+	return PLUGIN_LOG_LEVELS.indexOf(level) >= PLUGIN_LOG_LEVELS.indexOf(minimum);
+}
+function normalizePluginLogSource(raw) {
+	const stripped = String(raw || "").trim().replace(/^@[^/]+\//, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+	const bounded = (/^[a-z]/.test(stripped) ? stripped : `p-${stripped}`).slice(0, 64).replace(/-+$/g, "");
+	return SOURCE_RE.test(bounded) ? bounded : "dsh-plugin";
+}
+function normalizePluginLogEvent(raw) {
+	const cleaned = String(raw || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z]+/, "").slice(0, 128);
+	return EVENT_RE.test(cleaned) ? cleaned : "plugin.event";
+}
+/**
+* Parse a level specification like `debug` or `dsh-zhihu=debug,dsh-dot:warn,info`.
+* Source-specific rules win over a bare fallback level.
+*/
+function parsePluginLogLevel(spec, source, fallback = DEFAULT_PLUGIN_LOG_LEVEL) {
+	if (!spec || typeof spec !== "string") return fallback;
+	const normalizedSource = source ? normalizePluginLogSource(source) : void 0;
+	let wildcard;
+	for (const token of spec.split(",").map((part) => part.trim()).filter(Boolean)) {
+		const lowered = token.toLowerCase();
+		if (isPluginLogLevel(lowered)) {
+			wildcard = lowered;
+			continue;
+		}
+		const match = /^([^=:]+)[=:]([a-z]+)$/i.exec(token);
+		if (!match) continue;
+		const target = match[1].trim();
+		const candidate = match[2].trim().toLowerCase();
+		if (!isPluginLogLevel(candidate)) continue;
+		if (target === "*") {
+			wildcard = candidate;
+			continue;
+		}
+		if (normalizedSource && normalizePluginLogSource(target) === normalizedSource) return candidate;
+	}
+	return wildcard ?? fallback;
+}
+function sanitizePluginLogText(text, maxChars = PLUGIN_LOG_MAX_MESSAGE_CHARS) {
+	if (!text) return "";
+	if (CREDENTIAL_BODY_RE.test(text)) return "[omitted credential material]";
+	if (CHAT_PAYLOAD_RE.test(text)) return "[omitted chat payload]";
+	return truncateLogText(text.replace(AUTH_HEADER_RE, "$1: [redacted]").replace(BEARER_RE, "Bearer [redacted]").replace(SECRET_FIELD_RE, (full, prefix) => {
+		const value = full.slice(prefix.length);
+		if (value.startsWith("\"")) return `${prefix}"[redacted]"`;
+		if (value.startsWith("'")) return `${prefix}'[redacted]'`;
+		return `${prefix}[redacted]`;
+	}).replace(SECRET_QUERY_RE, "$1[redacted]").replace(URL_CREDENTIAL_RE, "$1[redacted]@").replace(BOOTSTRAP_RE, "/bootstrap/[redacted]").replace(KNOWN_TOKEN_RE, "[redacted]").replace(PATH_RE, "[path]"), maxChars);
+}
+function sanitizePluginLogContext(input) {
+	if (!input) return void 0;
+	const output = {};
+	for (const [key, value] of Object.entries(input).slice(0, 32)) {
+		if (value === void 0 || !CONTEXT_KEY_RE.test(key)) continue;
+		if (typeof value === "number" && !Number.isFinite(value)) continue;
+		if (SECRET_KEY_RE.test(key)) {
+			output[key] = "[redacted]";
+			continue;
+		}
+		output[key] = typeof value === "string" ? sanitizePluginLogText(value, 1e3) : value;
+	}
+	if (!Object.keys(output).length) return void 0;
+	if (JSON.stringify(output).length <= 8e3) return output;
+	return {
+		omitted: true,
+		reason: "Diagnostic context exceeded its size limit."
+	};
+}
+function sanitizePluginLogError(error) {
+	if (error === void 0) return void 0;
+	const row = error && typeof error === "object" ? error : {};
+	const rawMessage = typeof row.message === "string" ? row.message : String(error);
+	const result = {
+		name: typeof row.name === "string" && row.name.trim() ? truncateLogText(row.name.trim(), 100) : "Error",
+		message: sanitizePluginLogText(rawMessage) || "Unknown error"
+	};
+	if (typeof row.stack === "string" && row.stack.trim()) result.stack = sanitizePluginLogText(row.stack, 24e3);
+	if (typeof row.code === "string" && /^[A-Za-z0-9_./:-]{1,100}$/.test(row.code)) result.code = row.code;
+	else if (typeof row.code === "number" && Number.isFinite(row.code)) result.code = String(row.code);
+	return result;
+}
+function mergePluginLogContext(base, extra) {
+	if (!base) return extra;
+	if (!extra) return base;
+	return {
+		...base,
+		...extra
+	};
+}
+function buildPluginLogEntry(input, meta) {
+	const entry = {
+		version: 1,
+		at: meta.at.toISOString(),
+		level: isPluginLogLevel(input.level) ? input.level : "info",
+		source: normalizePluginLogSource(meta.source),
+		surface: meta.surface,
+		...meta.profile ? { profile: meta.profile } : {},
+		event: normalizePluginLogEvent(input.event),
+		message: sanitizePluginLogText(input.message || "No diagnostic message was provided.", PLUGIN_LOG_MAX_MESSAGE_CHARS),
+		...meta.pid !== void 0 ? { pid: meta.pid } : {}
+	};
+	const context = sanitizePluginLogContext(mergePluginLogContext(meta.correlation, input.context));
+	if (context) entry.context = context;
+	const error = sanitizePluginLogError(input.error);
+	if (error) entry.error = error;
+	return entry;
+}
+function createChildPluginLogger(parent, bound) {
+	return {
+		get source() {
+			return parent.source;
+		},
+		get file() {
+			return parent.file;
+		},
+		get lastWriteError() {
+			return parent.lastWriteError;
+		},
+		debug: (event, message, context) => parent.debug(event, message, mergePluginLogContext(bound, context)),
+		info: (event, message, context) => parent.info(event, message, mergePluginLogContext(bound, context)),
+		warn: (event, message, error, context) => parent.warn(event, message, error, mergePluginLogContext(bound, context)),
+		error: (event, message, error, context) => parent.error(event, message, error, mergePluginLogContext(bound, context)),
+		fault: (event, message, error, context) => parent.fault(event, message, error, mergePluginLogContext(bound, context)),
+		write: (input) => parent.write({
+			...input,
+			context: mergePluginLogContext(bound, input.context)
+		}),
+		child: (next) => createChildPluginLogger(parent, mergePluginLogContext(bound, next) ?? {})
+	};
+}
+function truncateLogText(text, maxChars) {
+	if (text.length <= maxChars) return text;
+	const marker = "[truncated]\n";
+	if (maxChars <= 12) return text.slice(0, Math.max(0, maxChars));
+	return `${marker}${text.slice(-(maxChars - 12))}`;
+}
+const PROFILE_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+const ARCHIVE_RE = /^[a-z][a-z0-9-]{0,63}\.\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.\d{3}Z\.\d+\.\d+\.jsonl$/;
+const correlationStorage = new AsyncLocalStorage();
+const processFileLoggers = /* @__PURE__ */ new Map();
+let operationSequence = 0;
+function safeProfileName(profile) {
+	const trimmed = String(profile ?? "").trim();
+	if (PROFILE_RE.test(trimmed)) return trimmed.toLowerCase();
+	const cleaned = trimmed.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+	return cleaned && PROFILE_RE.test(cleaned) ? cleaned : "default";
+}
+function pluginLogDirectory(home, profile = "default") {
+	return join(resolve(home), "logs", "plugins", safeProfileName(profile));
+}
+function resolveHostLogTarget(ctx, options = {}) {
+	const env = options.env ?? process.env;
+	if (options.directory?.trim()) {
+		const dir = resolve(options.directory.trim());
+		return {
+			directory: dir,
+			anchor: dir,
+			...options.profile ? { profile: safeProfileName(options.profile) } : {}
+		};
+	}
+	if (options.home?.trim()) {
+		const home = resolve(options.home.trim());
+		const profile = safeProfileName(options.profile);
+		return {
+			directory: pluginLogDirectory(home, profile),
+			anchor: home,
+			profile
+		};
+	}
+	if (env.DSH_PLUGIN_LOG_DIR?.trim()) {
+		const dir = resolve(env.DSH_PLUGIN_LOG_DIR.trim());
+		return {
+			directory: dir,
+			anchor: dir,
+			...options.profile ? { profile: safeProfileName(options.profile) } : {}
+		};
+	}
+	const host = ctx && typeof ctx === "object" ? ctx : void 0;
+	let profileCtx;
+	try {
+		profileCtx = host?.get?.("profileContext", false);
+	} catch {
+		try {
+			profileCtx = host?.get?.("profileContext");
+		} catch {
+			profileCtx = void 0;
+		}
+	}
+	if (typeof profileCtx?.home === "string" && profileCtx.home.trim() && typeof profileCtx.dir === "string" && profileCtx.dir.trim()) {
+		const home = resolve(profileCtx.home.trim());
+		const dir = resolve(profileCtx.dir.trim());
+		if (isInside(home, dir)) {
+			const profile = safeProfileName(typeof profileCtx.name === "string" ? profileCtx.name : basename(dir));
+			return {
+				directory: pluginLogDirectory(home, profile),
+				anchor: home,
+				profile
+			};
+		}
+	}
+	if (!Boolean(env.VITEST || env.NODE_TEST_CONTEXT) && typeof host?.baseUrl === "string" && host.baseUrl.trim()) {
+		const basePath = pathFromBaseUrl(host.baseUrl);
+		const configuredHome = resolve((env.DSH_HOME?.trim() || join(homedir(), ".dsh")).trim());
+		const profilesRoot = join(configuredHome, "profiles");
+		if (basePath && isInside(profilesRoot, basePath) && !samePath(profilesRoot, basePath)) {
+			const firstSegment = basePath.slice(profilesRoot.length).replace(/^[/\\]+/, "").split(/[/\\]/)[0];
+			if (firstSegment) {
+				const profile = safeProfileName(firstSegment);
+				return {
+					directory: pluginLogDirectory(configuredHome, profile),
+					anchor: configuredHome,
+					profile
+				};
+			}
+		}
+	}
+	return {
+		directory: null,
+		anchor: null,
+		...options.profile ? { profile: safeProfileName(options.profile) } : {}
+	};
+}
+/**
+* Synchronous, append-only rotating JSONL logger modeled on DSH Spaces
+* diagnostics: 7-day or 100 MiB active rotation, 7-day / 100 MiB archive
+* retention, secret and path redaction, and non-throwing write resilience.
+*/
+var RotatingPluginLogger = class {
+	source;
+	file;
+	lastError = null;
+	size = 0;
+	openedAt = 0;
+	initialized = false;
+	writing = false;
+	sequence = 0;
+	loggedWriteFailure = false;
+	recent = [];
+	directory;
+	anchor;
+	profile;
+	minimum;
+	now;
+	pid;
+	maxFileBytes;
+	maxArchiveBytes;
+	maxAgeMs;
+	recentLimit;
+	constructor(source, options = {}) {
+		this.source = normalizePluginLogSource(source);
+		const env = options.env ?? process.env;
+		const resolved = options.directory !== void 0 || options.home !== void 0 ? resolveHostLogTarget(void 0, options) : {
+			directory: null,
+			anchor: options.anchor ?? null,
+			profile: options.profile
+		};
+		this.directory = resolved.directory;
+		this.anchor = options.anchor ?? resolved.anchor;
+		this.profile = options.profile ?? resolved.profile;
+		this.file = this.directory ? join(this.directory, `${this.source}.jsonl`) : null;
+		this.minimum = options.minimumLevel ?? parsePluginLogLevel(env.DSH_PLUGIN_LOG_LEVEL, this.source, "info");
+		this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+		this.pid = options.pid ?? process.pid;
+		this.maxFileBytes = options.maxFileBytes ?? 104857600;
+		this.maxArchiveBytes = options.maxArchiveBytes ?? 104857600;
+		this.maxAgeMs = options.maxAgeMs ?? 6048e5;
+		this.recentLimit = Math.max(1, options.recentLimit ?? 200);
+	}
+	get lastWriteError() {
+		return this.lastError;
+	}
+	recentEntries(limit = this.recentLimit) {
+		return this.recent.slice(-Math.max(0, limit));
+	}
+	debug(event, message, context) {
+		return this.write({
+			level: "debug",
+			event,
+			message,
+			...context ? { context } : {}
+		});
+	}
+	info(event, message, context) {
+		return this.write({
+			level: "info",
+			event,
+			message,
+			...context ? { context } : {}
+		});
+	}
+	warn(event, message, error, context) {
+		return this.write({
+			level: "warn",
+			event,
+			message,
+			...error !== void 0 ? { error } : {},
+			...context ? { context } : {}
+		});
+	}
+	error(event, message, error, context) {
+		return this.write({
+			level: "error",
+			event,
+			message,
+			...error !== void 0 ? { error } : {},
+			...context ? { context } : {}
+		});
+	}
+	fault(event, message, error, context) {
+		return this.write({
+			level: "fault",
+			event,
+			message,
+			...error !== void 0 ? { error } : {},
+			...context ? { context } : {}
+		});
+	}
+	child(context) {
+		return createChildPluginLogger(this, context);
+	}
+	write(input) {
+		if (!pluginLogLevelEnabled(input.level, this.minimum) || this.writing) return false;
+		const at = this.now();
+		let entry;
+		let line;
+		try {
+			entry = buildPluginLogEntry(input, {
+				at,
+				source: this.source,
+				surface: "host",
+				profile: this.profile,
+				pid: this.pid,
+				correlation: correlationStorage.getStore()
+			});
+			line = `${JSON.stringify(entry)}\n`;
+		} catch {
+			return false;
+		}
+		this.pushRecent(entry);
+		if (!this.directory || !this.file) return true;
+		this.writing = true;
+		try {
+			this.openManagedDirectory();
+			this.prepare(at);
+			if (this.size > 0 && (this.size + Buffer.byteLength(line) > this.maxFileBytes || at.getTime() - this.openedAt >= this.maxAgeMs)) this.rotate(at);
+			appendFileSync(this.file, line, {
+				encoding: "utf8",
+				mode: 384
+			});
+			this.size += Buffer.byteLength(line);
+			this.prune(at);
+			this.lastError = null;
+			this.loggedWriteFailure = false;
+			return true;
+		} catch (error) {
+			const detail = sanitizePluginLogText(error instanceof Error ? error.message : String(error), 500);
+			this.lastError = `The plugin diagnostic log could not be written: ${detail}`;
+			this.initialized = false;
+			if (!this.loggedWriteFailure) {
+				this.loggedWriteFailure = true;
+				try {
+					process.stderr.write(`DSH Plugin (${this.source}): ${this.lastError}. The original operation continues unchanged.\n`);
+				} catch {}
+			}
+			return false;
+		} finally {
+			this.writing = false;
+		}
+	}
+	pushRecent(entry) {
+		this.recent.push(entry);
+		const overflow = this.recent.length - this.recentLimit;
+		if (overflow > 0) this.recent.splice(0, overflow);
+	}
+	prepare(at) {
+		if (this.initialized || !this.file) return;
+		this.openManagedDirectory();
+		const stat = this.regularFile(this.file);
+		this.size = stat?.size ?? 0;
+		const stamps = stat ? [stat.birthtimeMs, stat.mtimeMs].filter((value) => value > 0) : [];
+		this.openedAt = stamps.length ? Math.min(...stamps) : at.getTime();
+		this.initialized = true;
+	}
+	rotate(at) {
+		if (!this.directory || !this.file) return;
+		const stamp = at.toISOString().replace(/:/g, "-");
+		const name = `${this.source}.${stamp}.${this.pid}.${this.sequence++}.jsonl`;
+		if (!ARCHIVE_RE.test(name)) throw new Error("Diagnostic log archive name is invalid.");
+		const archive = join(this.directory, name);
+		if (lexists(archive)) throw new Error("Diagnostic log archive already exists.");
+		try {
+			renameSync(this.file, archive);
+		} catch (error) {
+			if (error.code === "ENOENT") {
+				this.size = 0;
+				this.openedAt = at.getTime();
+				return;
+			}
+			throw error;
+		}
+		this.size = 0;
+		this.openedAt = at.getTime();
+	}
+	rotateStaleActive(at) {
+		if (!this.file) return;
+		const stat = this.regularFile(this.file);
+		if (!stat || stat.size === 0) return;
+		if (at.getTime() - stat.mtimeMs < this.maxAgeMs) return;
+		this.rotate(at);
+	}
+	prune(at) {
+		if (!this.directory) return;
+		this.rotateStaleActive(at);
+		const archives = [];
+		let total = 0;
+		for (const name of readdirSync(this.directory)) {
+			if (!ARCHIVE_RE.test(name) || !name.startsWith(`${this.source}.`)) continue;
+			const file = join(this.directory, name);
+			const stat = lstatSync(file);
+			if (stat.isSymbolicLink() || !stat.isFile()) throw new Error("Diagnostic log archive is not a regular file.");
+			if (at.getTime() - stat.mtimeMs >= this.maxAgeMs) {
+				try {
+					unlinkSync(file);
+				} catch {}
+				continue;
+			}
+			archives.push({
+				name,
+				size: stat.size,
+				mtime: stat.mtimeMs
+			});
+			total += stat.size;
+		}
+		archives.sort((left, right) => left.mtime - right.mtime || left.name.localeCompare(right.name));
+		while (total > this.maxArchiveBytes && archives.length) {
+			const oldest = archives.shift();
+			try {
+				unlinkSync(join(this.directory, oldest.name));
+			} catch {}
+			total -= oldest.size;
+		}
+	}
+	openManagedDirectory() {
+		if (!this.directory) return;
+		if (this.anchor) {
+			if ((existsSync(this.anchor) ? lstatSync(this.anchor) : void 0)?.isSymbolicLink()) throw new Error("Diagnostic log anchor cannot be a symbolic link.");
+		}
+		mkdirSync(this.directory, {
+			recursive: true,
+			mode: 448
+		});
+		const stat = lstatSync(this.directory);
+		if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error("Diagnostic log directory is not a real directory.");
+		const realDir = realpathSync(this.directory);
+		if (this.anchor) {
+			if (!isInside(realpathSync(this.anchor), realDir)) throw new Error("Diagnostic log directory escaped its managed root.");
+		}
+	}
+	regularFile(file) {
+		try {
+			const stat = lstatSync(file);
+			if (stat.isSymbolicLink() || !stat.isFile()) throw new Error("Diagnostic log is not a regular file.");
+			const expected = join(realpathSync(dirname(file)), basename(file));
+			if (!samePath(realpathSync(file), expected)) throw new Error("Diagnostic log path could not be verified.");
+			return stat;
+		} catch (error) {
+			if (error.code === "ENOENT") return void 0;
+			throw error;
+		}
+	}
+};
+function createPluginLogger(ctxOrSource, maybeSource, maybeOptions) {
+	const hasCtx = typeof ctxOrSource !== "string";
+	const ctx = hasCtx ? ctxOrSource : void 0;
+	const source = hasCtx ? String(maybeSource ?? "dsh-plugin") : ctxOrSource;
+	const options = (hasCtx ? maybeOptions : maybeSource) ?? {};
+	const normalized = normalizePluginLogSource(source);
+	const target = resolveHostLogTarget(ctx, options);
+	let backing;
+	if (Boolean(target.directory && options.minimumLevel === void 0 && options.now === void 0 && options.pid === void 0 && options.maxFileBytes === void 0 && options.maxArchiveBytes === void 0 && options.maxAgeMs === void 0) && target.directory) {
+		const key = resolve(target.directory, `${normalized}.jsonl`);
+		let shared = processFileLoggers.get(key);
+		if (!shared) {
+			shared = new RotatingPluginLogger(normalized, {
+				...options,
+				directory: target.directory,
+				anchor: target.anchor,
+				profile: target.profile
+			});
+			processFileLoggers.set(key, shared);
+		}
+		backing = shared;
+	} else backing = new RotatingPluginLogger(normalized, {
+		...options,
+		...target.directory ? {
+			directory: target.directory,
+			anchor: target.anchor
+		} : {},
+		...target.profile ? { profile: target.profile } : {}
+	});
+	if (options.forwardHostWarnError === false || !ctx || typeof ctx !== "object") return backing;
+	return wrapWithHostForwarding(backing, ctx);
+}
+function installPluginLogger(ctx, source, options = {}) {
+	const logger = createPluginLogger(ctx, source, options);
+	logger.info("plugin.loaded", "Host plugin initialized.", options.loadedContext);
+	const host = ctx && typeof ctx === "object" ? ctx : void 0;
+	if (typeof host?.effect === "function") try {
+		host.effect(() => () => {
+			logger.debug("plugin.disposed", "Host plugin disposed.");
+		}, `${logger.source}.logger`);
+	} catch {}
+	return logger;
+}
+function wrapWithHostForwarding(backing, host) {
+	const forward = (input) => {
+		if (input.level !== "warn" && input.level !== "error" && input.level !== "fault") return;
+		try {
+			const hostLogger = host.logger;
+			if (!hostLogger) return;
+			const detail = input.error instanceof Error ? `${input.message} (${input.error.message})` : input.error !== void 0 ? `${input.message} (${String(input.error)})` : input.message;
+			const text = sanitizePluginLogText(`${backing.source} [${input.event}]: ${detail}`, 1e3);
+			if (input.level === "warn") {
+				if (typeof hostLogger.warn === "function") hostLogger.warn(text);
+			} else if (typeof hostLogger.error === "function") hostLogger.error(text);
+			else if (typeof hostLogger.warn === "function") hostLogger.warn(text);
+		} catch {}
+	};
+	const wrapped = {
+		get source() {
+			return backing.source;
+		},
+		get file() {
+			return backing.file;
+		},
+		get lastWriteError() {
+			return backing.lastWriteError;
+		},
+		debug: (event, message, context) => backing.debug(event, message, context),
+		info: (event, message, context) => backing.info(event, message, context),
+		warn: (event, message, error, context) => {
+			const wrote = backing.warn(event, message, error, context);
+			forward({
+				level: "warn",
+				event,
+				message,
+				error,
+				context
+			});
+			return wrote;
+		},
+		error: (event, message, error, context) => {
+			const wrote = backing.error(event, message, error, context);
+			forward({
+				level: "error",
+				event,
+				message,
+				error,
+				context
+			});
+			return wrote;
+		},
+		fault: (event, message, error, context) => {
+			const wrote = backing.fault(event, message, error, context);
+			forward({
+				level: "fault",
+				event,
+				message,
+				error,
+				context
+			});
+			return wrote;
+		},
+		write: (input) => {
+			const wrote = backing.write(input);
+			forward(input);
+			return wrote;
+		},
+		child: (context) => createChildPluginLogger(wrapped, context)
+	};
+	return wrapped;
+}
+function nextPluginOperationId(prefix = "op") {
+	return `${normalizePluginLogSource(prefix)}-${process.pid}-${++operationSequence}`;
+}
+function withPluginLogContext(context, action) {
+	const merged = mergePluginLogContext(correlationStorage.getStore(), context) ?? {};
+	return correlationStorage.run(merged, action);
+}
+function lexists(file) {
+	try {
+		lstatSync(file);
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+function pathFromBaseUrl(baseUrl) {
+	try {
+		return baseUrl.includes("://") ? resolve(fileURLToPath(baseUrl)) : resolve(baseUrl);
+	} catch {
+		return null;
+	}
+}
+function samePath(left, right) {
+	const a = resolve(left);
+	const b = resolve(right);
+	return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+function isInside(root, target) {
+	const rootResolved = resolve(root);
+	const targetResolved = resolve(target);
+	if (samePath(rootResolved, targetResolved)) return true;
+	const prefix = rootResolved.endsWith(sep) ? rootResolved : rootResolved + sep;
+	return process.platform === "win32" ? targetResolved.toLowerCase().startsWith(prefix.toLowerCase()) : targetResolved.startsWith(prefix);
+}
+//#endregion
+//#region ../dsh-plugin-kit/src/host-rpc.ts
+/** The shared authenticated HTTP boundary. Each plugin still owns its RPC envelope semantics. */
+function registerHostRpcTransport(ctx, channel, dispatch, options = {}) {
+	const bodyLimit = options.maxBodyBytes ?? 65536;
+	if (!Number.isSafeInteger(bodyLimit) || bodyLimit <= 0) throw new Error("Invalid RPC body limit");
+	const isEndpoint = options.isEndpoint ?? ((endpoint) => /^[a-z.]+$/.test(endpoint));
+	const log = options.logger;
+	return ctx.webServer.register({
+		kind: "prefix",
+		path: channel,
+		handler: async (req, res) => {
+			const reject = (status, error, override) => {
+				if (res.destroyed) return;
+				if (status === 413) res.writeHead(status, { connection: "close" });
+				else res.writeHead(status);
+				res.end(override ?? options.errorBody?.(status, error) ?? (status === 500 ? "rpc request failed" : ""));
+			};
+			let endpoint = "";
+			try {
+				if (typeof ctx.connection.requestRejection !== "function") {
+					log?.error("rpc.admission.unavailable", "Host RPC admission policy is unavailable.", void 0, {
+						channel,
+						status: 503
+					});
+					reject(503);
+					return;
+				}
+				const rejection = ctx.connection.requestRejection(req);
+				if (rejection !== void 0) {
+					log?.warn("rpc.admission.rejected", "Host RPC request rejected by connection policy.", void 0, {
+						channel,
+						status: rejection
+					});
+					reject(rejection);
+					return;
+				}
+				const pathname = new URL(req.url ?? "/", "http://dsh.internal").pathname;
+				endpoint = pathname.startsWith(`${channel}/`) ? pathname.slice(channel.length + 1) : "";
+				if (req.method !== "POST" || !isEndpoint(endpoint)) {
+					log?.debug("rpc.route.rejected", "Host RPC route or method rejected.", {
+						channel,
+						endpoint: endpoint || null,
+						method: req.method ?? null,
+						status: 404
+					});
+					reject(404);
+					return;
+				}
+				const contentType = String(req.headers["content-type"] ?? "").split(";", 1)[0]?.trim();
+				if ((options.caseInsensitiveContentType ? contentType.toLowerCase() : contentType) !== "application/json") {
+					log?.debug("rpc.content-type.rejected", "Host RPC content-type rejected.", {
+						channel,
+						endpoint,
+						status: 415
+					});
+					reject(415);
+					return;
+				}
+				const guarded = options.beforeBody?.(req, endpoint);
+				if (guarded) {
+					log?.debug("rpc.guard.rejected", "Host RPC request rejected before body read.", {
+						channel,
+						endpoint,
+						status: guarded.status
+					});
+					reject(guarded.status, void 0, guarded.body);
+					return;
+				}
+				const controller = new AbortController();
+				res.on("close", () => {
+					if (!res.writableEnded) controller.abort();
+				});
+				const chunks = [];
+				let size = 0;
+				for await (const chunk of req) {
+					const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+					size += buffer.length;
+					if (size > bodyLimit) {
+						log?.warn("rpc.body.too-large", "Host RPC request exceeded body limit.", void 0, {
+							channel,
+							endpoint,
+							maxBodyBytes: bodyLimit
+						});
+						reject(413);
+						req.destroy();
+						return;
+					}
+					chunks.push(buffer);
+				}
+				let body;
+				try {
+					body = JSON.parse(Buffer.concat(chunks).toString("utf8") || (options.emptyBodyAsNull ? "null" : ""));
+				} catch {
+					log?.debug("rpc.body.invalid-json", "Host RPC request body is not valid JSON.", {
+						channel,
+						endpoint,
+						status: 400
+					});
+					reject(400);
+					return;
+				}
+				if (log) await withPluginLogContext({
+					rpcChannel: channel,
+					rpcEndpoint: endpoint,
+					operationId: nextPluginOperationId("rpc")
+				}, () => dispatch(endpoint, body, controller.signal, res));
+				else await dispatch(endpoint, body, controller.signal, res);
+			} catch (error) {
+				log?.error("rpc.dispatch.failed", "Unhandled host RPC handler error.", error, {
+					channel,
+					endpoint: endpoint || null,
+					status: 500
+				});
+				reject(500, error);
+			}
+		}
+	});
+}
+/** Write the native Connection response envelope after a plugin has handled a request. */
+function sendHostRpcResponse(response, rpcId, result, noStore = true) {
+	if (response.destroyed) return;
+	response.writeHead(200, {
+		"content-type": "application/json",
+		...noStore ? { "cache-control": "no-store" } : {}
+	});
+	response.end(JSON.stringify({
+		type: "server-response",
+		rpcId,
+		result
+	}));
+}
+/** Safe host RPC registration. Missing requestRejection fails closed. */
+function registerHostRpc(ctx, channel, call, options = {}) {
+	const log = options.logger;
+	return registerHostRpcTransport(ctx, channel, async (endpoint, body, signal, res) => {
+		if (!body || typeof body !== "object" || Array.isArray(body)) {
+			log?.debug("rpc.envelope.invalid", "Host RPC envelope must be a JSON object.", {
+				channel,
+				endpoint
+			});
+			res.writeHead(400);
+			res.end();
+			return;
+		}
+		const request = body;
+		if (request.type !== "client-request" || request.method !== endpoint || typeof request.rpcId !== "string" || options.requirePayload && !Object.hasOwn(request, "payload")) {
+			log?.debug("rpc.envelope.invalid", "Host RPC envelope failed validation.", {
+				channel,
+				endpoint
+			});
+			res.writeHead(400);
+			res.end();
+			return;
+		}
+		const started = Date.now();
+		const raw = await call(endpoint, request.payload, signal);
+		const durationMs = Date.now() - started;
+		if (raw.ok) log?.debug("rpc.call.completed", "Host RPC call succeeded.", {
+			channel,
+			endpoint,
+			durationMs
+		});
+		else log?.warn("rpc.call.error", "Host RPC call returned an application error.", void 0, {
+			channel,
+			endpoint,
+			code: raw.error?.code ?? null,
+			durationMs
+		});
+		const result = raw.ok ? raw : {
+			...raw,
+			error: {
+				details: {},
+				...raw.error
+			}
+		};
+		sendHostRpcResponse(res, request.rpcId, result);
+	}, options);
+}
+//#endregion
+//#region src/index.ts
+const name = "deep-view";
+const inject = [
+	"tools",
+	"sessionController",
+	"sessions",
+	"agents",
+	"connection",
+	"webServer"
+];
+const MAX_REDIRECTS = 256;
+function resolveSessionId(redirects, sessionId) {
+	let current = sessionId;
+	const seen = /* @__PURE__ */ new Set();
+	while (!seen.has(current)) {
+		seen.add(current);
+		const next = redirects.get(current);
+		if (!next) break;
+		current = next;
+	}
+	return current;
+}
+function handoffPendingSession(pending, redirects, fromSessionId, toSessionId) {
+	if (!short(fromSessionId, 200) || !short(toSessionId, 200) || fromSessionId === toSessionId) return false;
+	const source = resolveSessionId(redirects, fromSessionId);
+	const target = resolveSessionId(redirects, toSessionId);
+	if (source === target) return false;
+	redirects.set(source, target);
+	if (fromSessionId !== source) redirects.set(fromSessionId, target);
+	while (redirects.size > MAX_REDIRECTS) {
+		const oldest = redirects.keys().next().value;
+		if (oldest === void 0) break;
+		redirects.delete(oldest);
+	}
+	const record = pending.get(source);
+	if (!record) return false;
+	pending.delete(source);
+	if (pending.has(target)) return false;
+	pending.set(target, {
+		...record,
+		sessionId: target
+	});
+	return true;
+}
+const isLiveRoot = (host, agent) => agent !== void 0 && host.agents.roots().some((root) => root.id === agent.id);
+const ok = (value) => ({
+	ok: true,
+	value
+});
+const fail = (code, message) => ({
+	ok: false,
+	error: {
+		code,
+		message
+	}
+});
+const short = (value, max = 160) => typeof value === "string" && value.length > 0 && value.length <= max;
+const checkedShown = (title, view) => checkShownView(title, view);
+const isShown = (value) => !("error" in value);
+function presentation(args, value) {
+	if (!isRecord(value) || value.owner !== "dsh-deep-view" || !["shown", "pending"].includes(String(value.status))) return null;
+	const shown = checkedShown(isRecord(args) ? args.title : void 0, isRecord(args) ? args.view : void 0);
+	if (!isShown(shown)) return null;
+	return {
+		owner: VIEW_OWNER,
+		...short(value.viewId, 80) ? { viewId: value.viewId } : {},
+		...shown,
+		awaitReply: value.awaitReply === true
+	};
+}
+function createShowViewTool(host, pending, makeId = randomUUID, logger) {
+	return {
+		name: "show_view",
+		description: [
+			"Attach one card below your final reply when a visual or interactive form beats prose: compared numbers, a trend, a share, progress; an estimate with user-adjustable inputs; or a choice the user answers afterwards (use ask_user_question when you cannot continue without it).",
+			"Prefer plain Markdown otherwise. Call once, then finish the reply; the card is not yet visible when this tool returns.",
+			"Never end on the call, wait or poll, repeat the card JSON, or claim the user saw it. Answers accept one reply, sent as the next user message. Never collect keys, tokens or passwords."
+		].join(" "),
+		parameters: {
+			type: "object",
+			properties: {
+				title: {
+					type: "string",
+					description: "Short heading above the card."
+				},
+				view: {
+					type: "object",
+					additionalProperties: true,
+					description: [
+						"One ViewNode, nodes nest under stack|row(children,let?).",
+						"Display: text,metric{label,value},table{columns:[{key,label}],rows:[[cell]]},chart{kind:bar|hbar|line|area|donut,categories,series:[{name?,values}]},progress{percent|value+max},callout{text},sources{items:[{label,url}]}.",
+						"Inputs: slider,number,choice,toggle{id,label,value}. A {\"=\":\"expr\"} formula replaces a value or cell, reading input ids and let names.",
+						"Answers(need await_reply true): options{id,options:[{label,description?}],multi?},confirm{id},form{id,fields:[{id,label,placeholder?}]},submit{id,label}. No html."
+					].join(" ")
+				},
+				await_reply: {
+					type: "boolean",
+					description: "Whether this card asks the user for a response."
+				}
+			},
+			required: ["view"]
+		},
+		output: {
+			schema: {
+				type: "object",
+				properties: {
+					owner: {
+						type: "string",
+						const: VIEW_OWNER
+					},
+					status: { type: "string" },
+					viewId: { type: "string" },
+					awaitReply: { type: "boolean" },
+					summary: { type: "string" }
+				},
+				required: [
+					"owner",
+					"status",
+					"awaitReply",
+					"summary"
+				],
+				additionalProperties: false
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: String(value.summary ?? "")
+			}],
+			presentationMeta: presentation
+		},
+		async execute(args, exec) {
+			const input = isRecord(args) ? args : {};
+			const shown = checkedShown(input.title, input.view);
+			if (!isShown(shown)) {
+				logger?.debug("view.invalid", "Rejected invalid show_view arguments.", {
+					sessionId: exec.agent?.id ?? null,
+					reason: shown.error
+				});
+				return {
+					owner: VIEW_OWNER,
+					status: "invalid",
+					awaitReply: false,
+					summary: shown.error
+				};
+			}
+			if (typeof input.await_reply !== "undefined" && typeof input.await_reply !== "boolean") return {
+				owner: VIEW_OWNER,
+				status: "invalid",
+				awaitReply: false,
+				summary: "await_reply: expected true or false"
+			};
+			const awaitReply = input.await_reply ?? shown.interactive;
+			if (awaitReply !== shown.interactive) return {
+				owner: VIEW_OWNER,
+				status: "invalid",
+				awaitReply: false,
+				summary: shown.interactive ? "This card has answer controls; omit await_reply or set it true." : "A display-only card cannot wait for an answer; omit await_reply or set it false."
+			};
+			const id = exec.agent?.id;
+			const agent = id === void 0 ? void 0 : host.agents.get(id);
+			if (awaitReply && !isLiveRoot(host, agent)) {
+				logger?.debug("view.non-root-rejected", "Rejected interactive show_view outside a live root session.", { sessionId: id ?? null });
+				return {
+					owner: VIEW_OWNER,
+					status: "invalid",
+					awaitReply: false,
+					summary: "An interactive view only works in a live root session. Put the question or decision in your response instead."
+				};
+			}
+			let viewId;
+			if (awaitReply && agent) {
+				viewId = makeId();
+				pending.set(agent.id, {
+					id: viewId,
+					sessionId: agent.id,
+					...exec.callId ? { callId: exec.callId } : {},
+					...shown
+				});
+			}
+			logger?.info("view.prepared", "Prepared Deep View card.", {
+				sessionId: agent?.id ?? id ?? null,
+				viewId: viewId ?? null,
+				awaitReply
+			});
+			return {
+				owner: VIEW_OWNER,
+				status: awaitReply ? "pending" : "shown",
+				...viewId ? { viewId } : {},
+				awaitReply,
+				summary: `Card prepared for the final reply. Finish with a concise final answer; do not call this tool again for the same card.${awaitReply ? " The user can answer the card after your reply finishes; do not wait or poll." : ""} ${viewSummary(shown.view)}`
+			};
+		},
+		isConcurrencySafe: () => false
+	};
+}
+function createRpc(host, pending, redirects = /* @__PURE__ */ new Map(), logger) {
+	const claims = /* @__PURE__ */ new Set();
+	return async (endpoint, payload, signal) => {
+		if (!isRecord(payload) || !short(payload.sessionId, 200)) return fail("bad-request", "A bounded sessionId is required");
+		const sessionId = resolveSessionId(redirects, payload.sessionId);
+		const record = pending.get(sessionId);
+		if (endpoint === "pending") return ok(record?.callId === payload.callId || payload.callId === void 0 ? record ?? null : null);
+		if (endpoint === "dismiss") {
+			if (record && record.id === payload.viewId) {
+				pending.delete(sessionId);
+				logger?.debug("view.dismissed", "Dismissed pending Deep View card.", {
+					sessionId,
+					viewId: record.id
+				});
+			}
+			return ok(true);
+		}
+		if (endpoint !== "reply") return fail("not-found", "Unknown Deep View endpoint");
+		if (!record || !short(payload.viewId, 80) || payload.viewId !== record.id || !short(payload.action, 160) || !isRecord(payload.values)) {
+			logger?.debug("reply.stale", "Rejected reply for stale or closed Deep View card.", { sessionId });
+			return fail("stale", "This view is no longer open");
+		}
+		if (claims.has(record.id)) return fail("busy", "This view is already being answered");
+		const checked = validateViewAnswer(record.view, payload.action, payload.values);
+		if (checked.error !== void 0) {
+			logger?.debug("reply.invalid", "Rejected invalid Deep View reply.", {
+				sessionId,
+				viewId: record.id,
+				action: payload.action,
+				reason: checked.error
+			});
+			return fail("invalid", checked.error);
+		}
+		claims.add(record.id);
+		pending.delete(sessionId);
+		let appended = false;
+		try {
+			if (signal.aborted) return fail("cancelled", "The request was cancelled");
+			const live = host.agents.get(sessionId);
+			const resolved = isLiveRoot(host, live) ? { agent: live } : await host.sessionController.resolveAgent(sessionId);
+			const agent = resolved.agent;
+			if (!agent || host.agents.get(agent.id) !== agent || !host.agents.roots().some((root) => root.id === agent.id)) throw new Error(("error" in resolved ? resolved.error?.message : void 0) ?? "The session is not a live root session");
+			if (signal.aborted) return fail("cancelled", "The request was cancelled");
+			const deepView = {
+				owner: VIEW_OWNER,
+				version: 1,
+				answer: {
+					id: record.id,
+					action: payload.action,
+					values: checked
+				}
+			};
+			agent.followup(createUserMessage({
+				content: [{
+					type: "text",
+					text: answerText(record, payload.action, checked)
+				}],
+				source: {
+					kind: "user",
+					deepView
+				}
+			}));
+			appended = true;
+			await host.sessions.flush(agent.session);
+			logger?.info("reply.submitted", "Submitted Deep View reply to live session.", {
+				sessionId: agent.id,
+				viewId: record.id,
+				action: payload.action
+			});
+			return ok({ answered: true });
+		} catch (error) {
+			logger?.error("reply.failed", "Failed to deliver Deep View reply.", error, {
+				sessionId,
+				viewId: record.id,
+				action: payload.action,
+				appended
+			});
+			return fail("internal", error instanceof Error ? error.message : String(error));
+		} finally {
+			if (!appended && !pending.has(sessionId)) pending.set(sessionId, record);
+			claims.delete(record.id);
+		}
+	};
+}
+async function apply(ctx) {
+	const host = ctx;
+	const logger = installPluginLogger(ctx, PLUGIN_NAME, { forwardHostWarnError: false });
+	const pending = /* @__PURE__ */ new Map();
+	const redirects = /* @__PURE__ */ new Map();
+	ctx.provide(HOST_SERVICE, { handoffSession: (fromSessionId, toSessionId) => {
+		const moved = handoffPendingSession(pending, redirects, fromSessionId, toSessionId);
+		if (moved) logger.debug("session.handoff", "Moved pending Deep View card across session handoff.", {
+			fromSessionId,
+			toSessionId
+		});
+		return moved;
+	} });
+	ctx.effect(() => {
+		if (host.tools.get("show_view")) {
+			logger.warn("tool.already-registered", "show_view is already registered by another plugin; skipping registration.");
+			host.logger?.warn("deep-view: show_view is already registered by another plugin; this bundle stays disabled for its own tool");
+			return () => {};
+		}
+		try {
+			return host.tools.register(createShowViewTool(host, pending, randomUUID, logger));
+		} catch (error) {
+			logger.warn("tool.register-failed", "show_view tool registration failed.", error);
+			host.logger?.warn("deep-view: show_view registration skipped: %s", error instanceof Error ? error.message : String(error));
+			return () => {};
+		}
+	}, "deep-view.tool");
+	ctx.effect(() => ctx.on("session/event", (session, event) => {
+		if (event.type !== "user/message" || !isRecord(event.data) || !isRecord(event.data.source) || event.data.source.kind !== "user") return;
+		pending.delete(resolveSessionId(redirects, session.id));
+	}), "deep-view.close-pending");
+	ctx.effect(() => registerHostRpc(host, RPC_CHANNEL, createRpc(host, pending, redirects, logger), {
+		maxBodyBytes: 24576,
+		logger
+	}), "deep-view.rpc");
+}
+//#endregion
+export { apply, createRpc, createShowViewTool, handoffPendingSession, inject, name, resolveSessionId };
+
+//# sourceMappingURL=index.js.map