@vanadium-23/dsh-ping 0.1.0

package/lib/channels-CpGxdbPv.js

@@ -0,0 +1,426 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+//#region lib/types/decide.js
+/**
+* The decision core: whether to notify, and what the notification says.
+*
+* Everything here is a pure function so the interesting behaviour — the
+* "don't be annoying" rules and the text assembly — is testable without a
+* live harness, a desktop, or a PowerShell.
+* @module dsh-ping/decide
+*/
+/**
+* Decide whether one fact should reach the user.
+*
+* Order matters: a disabled kind is a configuration statement, a subagent is a
+* structural statement, and both outrank the rate limits, so the reported
+* reason always names the real cause.
+* @param input - the fact plus the limits and bookkeeping it is judged against.
+* @returns the verdict and a short reason.
+*/
+function shouldNotify(input) {
+	const { fact, limits } = input;
+	if (!limits.enabled) return {
+		notify: false,
+		reason: "plugin-disabled"
+	};
+	if (!limits.kinds[fact.kind]) return {
+		notify: false,
+		reason: `kind-disabled:${fact.kind}`
+	};
+	if (limits.rootsOnly && !input.isRoot) return {
+		notify: false,
+		reason: "subagent"
+	};
+	if (limits.cooldownMs > 0 && input.lastNotifiedAt !== void 0 && input.now - input.lastNotifiedAt < limits.cooldownMs) return {
+		notify: false,
+		reason: "cooldown"
+	};
+	if (fact.kind === "done") {
+		if ((fact.durationMs ?? 0) < limits.minTurnDurationMs) return {
+			notify: false,
+			reason: "too-short"
+		};
+	}
+	return {
+		notify: true,
+		reason: "ok"
+	};
+}
+/**
+* Collapse a value into one printable line.
+*
+* Newlines are removed rather than kept: the Windows toast path carries text
+* through an environment variable and a here-string, and a single line cannot
+* terminate either of them.
+* @param value - raw text.
+* @param maxChars - maximum kept characters (0 keeps everything).
+* @returns the flattened, truncated text.
+*/
+function flatten(value, maxChars = 0) {
+	const cleaned = value.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
+	if (maxChars <= 0 || cleaned.length <= maxChars) return cleaned;
+	return `${cleaned.slice(0, Math.max(1, maxChars - 1)).trimEnd()}…`;
+}
+/**
+* Last path segment, used as a short workspace label.
+* @param cwd - an absolute working directory.
+* @returns the final segment, or an empty string.
+*/
+function workspaceOf(cwd) {
+	if (cwd === void 0) return "";
+	const trimmed = cwd.replace(/[\\/]+$/, "");
+	if (trimmed === "") return "";
+	const parts = trimmed.split(/[\\/]/);
+	return parts[parts.length - 1] ?? "";
+}
+/**
+* Human duration, Chinese units to match the default headings.
+* @param ms - duration in milliseconds.
+* @returns a compact label such as `2 分 13 秒`.
+*/
+function formatDuration(ms) {
+	if (ms === void 0 || !Number.isFinite(ms) || ms < 0) return "";
+	const totalSeconds = Math.round(ms / 1e3);
+	if (totalSeconds < 60) return `${String(totalSeconds)} 秒`;
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	if (minutes < 60) return seconds === 0 ? `${String(minutes)} 分` : `${String(minutes)} 分 ${String(seconds)} 秒`;
+	const hours = Math.floor(minutes / 60);
+	const rest = minutes % 60;
+	return rest === 0 ? `${String(hours)} 小时` : `${String(hours)} 小时 ${String(rest)} 分`;
+}
+/**
+* Render the notice for one fact.
+*
+* Shape: the heading states what happened, the first line carries the payload
+* (or the session identity when there is none), and the last line always says
+* which workspace and how long — that is what makes several concurrent
+* sessions distinguishable at a glance.
+* @param fact - the fact to render.
+* @param titles - per-kind headings.
+* @param maxBodyChars - maximum characters of the payload line.
+* @returns the notice.
+*/
+function buildNotice(fact, titles, maxBodyChars) {
+	const title = titles[fact.kind];
+	const workspace = workspaceOf(fact.cwd);
+	const subject = flatten(fact.sessionTitle ?? "", 80) || workspace || "DSH 会话";
+	const detail = fact.detail === void 0 ? "" : flatten(fact.detail, maxBodyChars);
+	const meta = [workspace === subject ? "" : workspace, formatDuration(fact.durationMs)].filter((part) => part !== "").join(" · ");
+	const lines = [];
+	if (detail !== "") {
+		lines.push(detail);
+		const attribution = [subject, meta].filter((part) => part !== "").join(" · ");
+		if (attribution !== "") lines.push(attribution);
+	} else {
+		lines.push(subject);
+		if (meta !== "" && meta !== subject) lines.push(meta);
+	}
+	return {
+		title,
+		lines: lines.slice(0, 2)
+	};
+}
+/**
+* Escape text for inclusion in the toast XML.
+* @param value - raw text.
+* @returns XML-safe text.
+*/
+function escapeXml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+//#endregion
+//#region lib/types/defaults.js
+/**
+* Configuration shape and defaults.
+*
+* Kept free of every runtime import — including the schema library — so the
+* standalone smoke test can reuse the defaults without pulling a
+* `@deepseek-ai/*` module into a CLI that has to run outside the harness.
+* @module dsh-ping/defaults
+*/
+/** The defaults, restated by the schema in `index.ts` so the loader applies them too. */
+const DEFAULTS = {
+	enabled: true,
+	notifyOn: {
+		done: true,
+		error: true,
+		approval: true,
+		question: true
+	},
+	rootsOnly: true,
+	cooldownMs: 3e4,
+	minTurnDurationMs: 2e4,
+	channels: {
+		toast: true,
+		console: true,
+		webhook: false
+	},
+	webhookUrl: "",
+	webhookTimeoutMs: 5e3,
+	url: "",
+	maxBodyChars: 180,
+	toastAppId: "",
+	toastSoundDone: "ms-winsoundevent:Notification.Default",
+	toastSoundAttention: "ms-winsoundevent:Notification.Reminder",
+	powershellPath: "",
+	titles: {
+		done: "DSH · 任务完成",
+		error: "DSH · 出错了",
+		approval: "DSH · 等你批准",
+		question: "DSH · 等你回答"
+	},
+	debug: false
+};
+/**
+* Merge a partially applied configuration over the defaults.
+*
+* The loader normally hands over a fully defaulted object, but a deployment
+* that instantiates the plugin directly should not have to.
+* @param config - raw configuration.
+* @returns a complete configuration.
+*/
+function resolveConfig(config) {
+	const source = config ?? {};
+	return {
+		...DEFAULTS,
+		...source,
+		notifyOn: {
+			...DEFAULTS.notifyOn,
+			...source.notifyOn
+		},
+		channels: {
+			...DEFAULTS.channels,
+			...source.channels
+		},
+		titles: {
+			...DEFAULTS.titles,
+			...source.titles
+		}
+	};
+}
+//#endregion
+//#region lib/types/channels.js
+/**
+* Delivery channels: Windows toast, console line, optional webhook.
+*
+* All three are best-effort by contract — a notification that cannot be shown
+* must never affect the harness, so every failure is logged and swallowed.
+* @module dsh-ping/channels
+*/
+/**
+* The toast script, sent as one `-EncodedCommand` payload.
+*
+* It is a constant. No session text is ever concatenated into PowerShell
+* source, so no amount of text in a session title, an error message, or a tool
+* name can reach the PowerShell parser: the text arrives as an XML document in
+* an environment variable and is handed straight to the WinRT XML parser.
+*/
+const TOAST_SCRIPT = `$ErrorActionPreference = 'Stop'
+[void][Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime]
+[void][Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType=WindowsRuntime]
+$xml = New-Object Windows.Data.Xml.Dom.XmlDocument
+$xml.LoadXml([Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($env:DSH_PING_XML)))
+$toast = New-Object Windows.UI.Notifications.ToastNotification $xml
+$appId = $env:DSH_PING_APPID
+if ([string]::IsNullOrEmpty($appId)) { $appId = '{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe' }
+[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier($appId).Show($toast)
+`;
+/**
+* Render the toast XML payload.
+* @param notice - the heading and body lines.
+* @param delivery - presentation options.
+* @returns a complete `<toast>` document.
+*/
+function buildToastXml(notice, delivery) {
+	const attributes = [delivery.url === void 0 || delivery.url === "" ? "" : `activationType="protocol" launch="${escapeXml(delivery.url)}"`, delivery.long === true ? "duration=\"long\"" : ""].filter((part) => part !== "").join(" ");
+	const texts = [notice.title, ...notice.lines].map((line) => `      <text>${escapeXml(line)}</text>`).join("\n");
+	const audio = delivery.sound === void 0 || delivery.sound === "" ? "  <audio silent=\"true\"/>" : `  <audio src="${escapeXml(delivery.sound)}" loop="false" silent="false"/>`;
+	return [
+		`<toast ${attributes}>`.replace(" >", ">"),
+		"  <visual>",
+		"    <binding template=\"ToastGeneric\">",
+		texts,
+		"    </binding>",
+		"  </visual>",
+		audio,
+		"</toast>"
+	].join("\n");
+}
+/**
+* Encode a script for `powershell.exe -EncodedCommand`.
+* @param script - PowerShell source.
+* @returns base64 of the UTF-16LE script.
+*/
+function encodeCommand(script) {
+	return Buffer.from(script, "utf16le").toString("base64");
+}
+/**
+* Resolve the Windows PowerShell 5.1 executable.
+*
+* WinRT type projection is a 5.1 feature; `pwsh` is not a substitute, so the
+* in-box path is used rather than a PATH lookup that could find PowerShell 7.
+* @param configured - an explicit path from configuration.
+* @returns the executable path, or `undefined` when unavailable.
+*/
+function resolvePowershell(configured) {
+	if (configured !== void 0 && configured !== "" && existsSync(configured)) return configured;
+	if (process.platform !== "win32") return void 0;
+	const path = join(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+	return existsSync(path) ? path : void 0;
+}
+/** Environment names Windows PowerShell needs to start cleanly. */
+const KEEP_ENV = [
+	"SystemRoot",
+	"windir",
+	"SystemDrive",
+	"PATH",
+	"Path",
+	"PATHEXT",
+	"COMSPEC",
+	"TEMP",
+	"TMP",
+	"USERPROFILE",
+	"USERNAME",
+	"COMPUTERNAME",
+	"NUMBER_OF_PROCESSORS",
+	"PSModulePath",
+	"LANG",
+	"LC_ALL"
+];
+/**
+* Build a minimal child environment.
+*
+* A notification process has no business inheriting API keys, so the
+* environment is rebuilt from an allowlist instead of copied.
+* @returns the environment for the toast helper.
+*/
+function minimalEnv() {
+	const env = {};
+	for (const name of KEEP_ENV) {
+		const value = process.env[name];
+		if (value !== void 0) env[name] = value;
+	}
+	return env;
+}
+/**
+* Show a Windows toast. Fire-and-forget by design.
+* @param notice - the heading and body lines.
+* @param delivery - presentation options.
+* @param log - diagnostic sink.
+* @returns true when the helper was started.
+*/
+function sendToast(notice, delivery, log) {
+	const powershell = resolvePowershell(delivery.powershellPath);
+	if (powershell === void 0) {
+		log("toast channel unavailable: Windows PowerShell 5.1 not found");
+		return false;
+	}
+	const xml = buildToastXml(notice, delivery);
+	try {
+		const child = spawn(powershell, [
+			"-NoProfile",
+			"-NonInteractive",
+			"-STA",
+			"-WindowStyle",
+			"Hidden",
+			"-EncodedCommand",
+			encodeCommand(TOAST_SCRIPT)
+		], {
+			windowsHide: true,
+			detached: false,
+			stdio: "ignore",
+			env: {
+				...minimalEnv(),
+				DSH_PING_XML: Buffer.from(xml, "utf16le").toString("base64"),
+				DSH_PING_APPID: delivery.appId
+			}
+		});
+		child.on("error", (error) => {
+			log(`toast helper failed: ${error.message}`);
+		});
+		child.unref();
+		return true;
+	} catch (error) {
+		log(`toast helper could not start: ${error instanceof Error ? error.message : String(error)}`);
+		return false;
+	}
+}
+/**
+* Show a Windows toast and wait for the helper to finish.
+*
+* The plugin never uses this — a live notification must not block a session
+* event — but a diagnostic run has to see the helper's exit code to tell
+* "shown" apart from "silently refused".
+* @param notice - the heading and body lines.
+* @param delivery - presentation options.
+* @returns the helper's exit code and captured error output.
+*/
+function sendToastSync(notice, delivery) {
+	const powershell = resolvePowershell(delivery.powershellPath);
+	if (powershell === void 0) return {
+		started: false,
+		code: null,
+		output: "Windows PowerShell 5.1 not found"
+	};
+	const xml = buildToastXml(notice, delivery);
+	const result = spawnSync(powershell, [
+		"-NoProfile",
+		"-NonInteractive",
+		"-STA",
+		"-WindowStyle",
+		"Hidden",
+		"-EncodedCommand",
+		encodeCommand(TOAST_SCRIPT)
+	], {
+		windowsHide: true,
+		encoding: "utf8",
+		timeout: 2e4,
+		env: {
+			...minimalEnv(),
+			DSH_PING_XML: Buffer.from(xml, "utf16le").toString("base64"),
+			DSH_PING_APPID: delivery.appId
+		}
+	});
+	const output = `${result.stderr ?? ""}${result.stdout ?? ""}`.trim();
+	return {
+		started: true,
+		code: result.status,
+		output
+	};
+}
+/**
+* Write the notice to stderr, where the launching terminal shows it.
+* @param notice - the heading and body lines.
+* @param log - diagnostic sink.
+*/
+function sendConsole(notice, log) {
+	log(`${notice.title}${notice.lines.length === 0 ? "" : ` — ${notice.lines.join(" · ")}`}`);
+}
+/**
+* POST the notice to a webhook.
+* @param payload - the JSON body.
+* @param url - destination URL.
+* @param timeoutMs - request budget.
+* @param log - diagnostic sink.
+* @returns a promise that settles when the attempt finishes.
+*/
+async function sendWebhook(payload, url, timeoutMs, log) {
+	if (url === "") return;
+	try {
+		const response = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(payload),
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+		await response.body?.cancel();
+		if (!response.ok) log(`webhook answered ${String(response.status)}`);
+	} catch (error) {
+		log(`webhook failed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+//#endregion
+export { DEFAULTS as a, shouldNotify as c, sendWebhook as i, sendToast as n, resolveConfig as o, sendToastSync as r, buildNotice as s, sendConsole as t };