@daandden/notification-hooks 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+- Initial standalone release of `@daandden/notification-hooks`, an installable OMP plugin that forwards `ask_waiting` and `completion` lifecycle events to a shell command.

package/README.md

@@ -0,0 +1,156 @@
+# Notification Hooks
+
+`@daandden/notification-hooks` is an installable OMP plugin that forwards selected hook lifecycle events to a shell command.
+
+v1 emits two events:
+- `ask_waiting` when the `ask` tool is waiting for user input
+- `completion` when an agent run has fully settled after retries and auto-compaction
+
+The hook sends the structured payload on stdin and mirrors key metadata through `OMP_NOTIFY_*` environment variables.
+
+## Install
+
+```bash
+omp plugin install @daandden/notification-hooks
+```
+
+## Configure
+
+Set the command and optional behavior with `omp plugin config` commands:
+
+```bash
+omp plugin config set @daandden/notification-hooks command 'notify-send "$OMP_NOTIFY_EVENT" "$OMP_NOTIFY_MESSAGE"'
+omp plugin config set @daandden/notification-hooks shell /bin/sh
+omp plugin config set @daandden/notification-hooks timeoutMs 5000
+omp plugin config set @daandden/notification-hooks notifyOnCompletion true
+omp plugin config set @daandden/notification-hooks notifyOnAsk true
+```
+
+Inspect current settings:
+
+```bash
+omp plugin config list @daandden/notification-hooks
+```
+
+### Settings
+
+| Setting | Type | Default | Purpose |
+| --- | --- | --- | --- |
+| `command` | string | disabled | Shell command to run. Empty or unset disables notifications. |
+| `shell` | string | `/bin/sh` | Shell binary used to execute `command`. |
+| `timeoutMs` | number | `5000` | Maximum time before the subprocess is killed and logged as a warning. |
+| `notifyOnCompletion` | boolean | `true` | Emit `completion` notifications. |
+| `notifyOnAsk` | boolean | `true` | Emit `ask_waiting` notifications. |
+
+## Environment variables
+
+Each setting also has an env fallback:
+- `OMP_NOTIFICATION_COMMAND`
+- `OMP_NOTIFICATION_SHELL`
+- `OMP_NOTIFICATION_TIMEOUT_MS`
+- `OMP_NOTIFICATION_NOTIFY_ON_COMPLETION`
+- `OMP_NOTIFICATION_NOTIFY_ON_ASK`
+
+Every notification subprocess receives these payload-derived env vars:
+- `OMP_NOTIFY_EVENT`
+- `OMP_NOTIFY_MESSAGE`
+- `OMP_NOTIFY_CWD`
+- `OMP_NOTIFY_TIMESTAMP`
+- `OMP_NOTIFY_SESSION_NAME`
+- `OMP_NOTIFY_SESSION_FILE`
+- `OMP_NOTIFY_TOOL_NAME`
+- `OMP_NOTIFY_QUESTION_COUNT`
+
+## Example commands
+
+### macOS via osascript
+
+```bash
+omp plugin config set @daandden/notification-hooks command 'osascript -e "display notification \"$OMP_NOTIFY_MESSAGE\" with title \"OMP\" subtitle \"$OMP_NOTIFY_EVENT\""'
+```
+
+### Linux via notify-send
+
+```bash
+omp plugin config set @daandden/notification-hooks command 'notify-send "$OMP_NOTIFY_EVENT" "$OMP_NOTIFY_MESSAGE"'
+```
+
+### Webhook bridge
+
+```bash
+omp plugin config set @daandden/notification-hooks command 'payload=$(cat); jq -n --argjson body "$payload" '{"'"'text'"'": $body.message, "'"'event'"'": $body.event, "'"'session'"'": $body.session}' | curl -fsS -H '"'"'content-type: application/json'"'"' -d @- https://example.invalid/hooks/omp'
+```
+
+### Capture payloads to disk
+
+```bash
+omp plugin config set @daandden/notification-hooks command 'cat > /tmp/omp-notify.json'
+```
+
+## JSON payload
+
+Example `ask_waiting` payload:
+
+```json
+{
+  "event": "ask_waiting",
+  "message": "Demo session: Waiting for input",
+  "timestamp": 1742371200000,
+  "cwd": "/workspace/project",
+  "session": {
+    "name": "Demo session",
+    "file": "/workspace/.omp/agent/sessions/demo.jsonl"
+  },
+  "toolName": "ask",
+  "ask": {
+    "questionCount": 1,
+    "questions": [
+      {
+        "id": "deploy",
+        "question": "Ship this change?",
+        "options": ["Yes", "No"],
+        "multi": false,
+        "recommended": 0
+      }
+    ]
+  }
+}
+```
+
+Example `completion` payload:
+
+```json
+{
+  "event": "completion",
+  "message": "Complete",
+  "timestamp": 1742371205000,
+  "cwd": "/workspace/project",
+  "session": {
+    "file": "/workspace/.omp/agent/sessions/demo.jsonl"
+  }
+}
+```
+
+## Lifecycle behavior
+
+Completion notifications are intentionally deferred. The hook treats `agent_end` as a completion candidate, then cancels or reschedules based on follow-up lifecycle events:
+- cancel on `auto_retry_start`
+- cancel on `auto_compaction_start`
+- cancel on `turn_start`
+- cancel on `session_shutdown`
+- reschedule on `auto_retry_end` when `success === false`
+- reschedule on `auto_compaction_end` when `willRetry === false` and the context is still idle with no queued messages
+
+This prevents false-positive completion notifications during retry or auto-compaction recovery.
+
+## Manual smoke test
+
+1. Install the plugin: `omp plugin install @daandden/notification-hooks`
+2. Configure a capture command: `omp plugin config set @daandden/notification-hooks command 'cat > /tmp/omp-notify.json'`
+3. Trigger an `ask` flow and confirm `/tmp/omp-notify.json` contains an `ask_waiting` payload.
+4. Let the agent fully settle and confirm the file contains exactly one final `completion` payload, not an intermediate retry or compaction payload.
+5. If the command fails or times out, inspect `~/.omp/logs/omp.YYYY-MM-DD.log` for warning entries.
+
+## Failure behavior
+
+Notification subprocess failures are non-fatal. Non-zero exit codes, spawn errors, and timeouts are logged through `@oh-my-pi/pi-utils`, but they do not fail or block the agent workflow.

package/package.json

@@ -0,0 +1,77 @@
+{
+	"type": "module",
+	"name": "@daandden/notification-hooks",
+	"version": "0.1.0",
+	"description": "OMP plugin package for external notification hooks",
+	"author": "daandden",
+	"license": "MIT",
+	"keywords": ["omp", "plugin", "hooks", "notifications"],
+	"scripts": {
+		"check": "tsgo -p tsconfig.json",
+		"test": "bun test test/notification-hooks.test.ts"
+	},
+	"dependencies": {
+		"@oh-my-pi/pi-coding-agent": "^13.13.2",
+		"@oh-my-pi/pi-utils": "^13.13.2"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.3"
+	},
+	"engines": {
+		"bun": ">=1.3.7"
+	},
+	"publishConfig": {
+		"access": "public",
+		"registry": "https://registry.npmjs.org/"
+	},
+	"omp": {
+		"hooks": "./src/index.ts",
+		"settings": {
+			"command": {
+				"type": "string",
+				"description": "Shell command to run for notification events. Leave empty to disable notifications.",
+				"env": "OMP_NOTIFICATION_COMMAND"
+			},
+			"shell": {
+				"type": "string",
+				"description": "Shell executable used to invoke the notification command.",
+				"default": "/bin/sh",
+				"env": "OMP_NOTIFICATION_SHELL"
+			},
+			"timeoutMs": {
+				"type": "number",
+				"description": "Maximum time to wait for a notification command before it is killed.",
+				"default": 5000,
+				"min": 1,
+				"env": "OMP_NOTIFICATION_TIMEOUT_MS"
+			},
+			"notifyOnCompletion": {
+				"type": "boolean",
+				"description": "Send a notification when an agent run fully settles.",
+				"default": true,
+				"env": "OMP_NOTIFICATION_NOTIFY_ON_COMPLETION"
+			},
+			"notifyOnAsk": {
+				"type": "boolean",
+				"description": "Send a notification when the ask tool is waiting for input.",
+				"default": true,
+				"env": "OMP_NOTIFICATION_NOTIFY_ON_ASK"
+			}
+		}
+	},
+	"files": ["src", "README.md", "CHANGELOG.md"],
+	"exports": {
+		"./config": {
+			"types": "./src/config.ts",
+			"import": "./src/config.ts"
+		},
+		"./payload": {
+			"types": "./src/payload.ts",
+			"import": "./src/payload.ts"
+		},
+		"./notify": {
+			"types": "./src/notify.ts",
+			"import": "./src/notify.ts"
+		}
+	}
+}

package/src/config.ts

@@ -0,0 +1,72 @@
+import { getPluginSettings } from "@oh-my-pi/pi-coding-agent/extensibility/plugins";
+
+export type NotificationEventType = "ask_waiting" | "completion";
+
+export interface HookNotificationConfig {
+	command: string | null;
+	shell: string;
+	timeoutMs: number;
+	notifyOnCompletion: boolean;
+	notifyOnAsk: boolean;
+}
+
+const PLUGIN_NAME = "@daandden/notification-hooks";
+const DEFAULT_SHELL = "/bin/sh";
+const DEFAULT_TIMEOUT_MS = 5_000;
+const DEFAULT_NOTIFY_ON_COMPLETION = true;
+const DEFAULT_NOTIFY_ON_ASK = true;
+
+function parseNonEmptyString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function parseCommand(value: unknown): string | null | undefined {
+	if (value === null) return null;
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+
+function parseTimeoutMs(value: unknown): number | undefined {
+	const numeric = typeof value === "number" ? value : typeof value === "string" ? Number(value.trim()) : Number.NaN;
+	if (!Number.isFinite(numeric) || numeric <= 0) return undefined;
+	return Math.floor(numeric);
+}
+
+function parseBoolean(value: unknown): boolean | undefined {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string") return undefined;
+	const normalized = value.trim().toLowerCase();
+	if (["1", "true", "yes", "on"].includes(normalized)) return true;
+	if (["0", "false", "no", "off"].includes(normalized)) return false;
+	return undefined;
+}
+
+export async function resolveHookNotificationConfig(cwd: string): Promise<HookNotificationConfig> {
+	const pluginSettings = await getPluginSettings(PLUGIN_NAME, cwd);
+
+	const command = parseCommand(pluginSettings.command) ?? parseCommand(Bun.env.OMP_NOTIFICATION_COMMAND) ?? null;
+	const shell = parseNonEmptyString(pluginSettings.shell) ?? parseNonEmptyString(Bun.env.OMP_NOTIFICATION_SHELL) ?? DEFAULT_SHELL;
+	const timeoutMs =
+		parseTimeoutMs(pluginSettings.timeoutMs) ??
+		parseTimeoutMs(Bun.env.OMP_NOTIFICATION_TIMEOUT_MS) ??
+		DEFAULT_TIMEOUT_MS;
+	const notifyOnCompletion =
+		parseBoolean(pluginSettings.notifyOnCompletion) ??
+		parseBoolean(Bun.env.OMP_NOTIFICATION_NOTIFY_ON_COMPLETION) ??
+		DEFAULT_NOTIFY_ON_COMPLETION;
+	const notifyOnAsk =
+		parseBoolean(pluginSettings.notifyOnAsk) ??
+		parseBoolean(Bun.env.OMP_NOTIFICATION_NOTIFY_ON_ASK) ??
+		DEFAULT_NOTIFY_ON_ASK;
+
+	return {
+		command,
+		shell,
+		timeoutMs,
+		notifyOnCompletion,
+		notifyOnAsk,
+	};
+}

package/src/index.ts

@@ -0,0 +1,188 @@
+import type {
+	AutoCompactionEndEvent,
+	HookAPI,
+	HookContext,
+	ToolCallEvent,
+} from "@oh-my-pi/pi-coding-agent/extensibility/hooks";
+import { logger } from "@oh-my-pi/pi-utils";
+import { buildAskWaitingPayload, buildCompletionPayload, type AskQuestionPayload, type NotificationPayload } from "./payload";
+import { resolveHookNotificationConfig } from "./config";
+import { runHookNotification } from "./notify";
+
+interface SessionMetadata {
+	cwd: string;
+	sessionFile?: string;
+	sessionName?: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function parseNonEmptyString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function parseBoolean(value: unknown): boolean {
+	return value === true;
+}
+
+function parseOptionLabels(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const labels: string[] = [];
+	for (const option of value) {
+		if (!isRecord(option)) return undefined;
+		const label = parseNonEmptyString(option.label);
+		if (label === undefined) return undefined;
+		labels.push(label);
+	}
+	return labels;
+}
+
+function parseRecommendedIndex(value: unknown, optionCount: number): number | undefined {
+	if (typeof value !== "number") return undefined;
+	if (!Number.isInteger(value) || value < 0 || value >= optionCount) return undefined;
+	return value;
+}
+
+function parseAskQuestion(value: unknown): AskQuestionPayload | undefined {
+	if (!isRecord(value)) return undefined;
+	const id = parseNonEmptyString(value.id);
+	const question = parseNonEmptyString(value.question);
+	const options = parseOptionLabels(value.options);
+	if (id === undefined || question === undefined || options === undefined) return undefined;
+	const recommended = parseRecommendedIndex(value.recommended, options.length);
+	return {
+		id,
+		question,
+		options,
+		multi: parseBoolean(value.multi),
+		...(recommended === undefined ? {} : { recommended }),
+	};
+}
+
+function parseAskQuestions(input: Record<string, unknown>): AskQuestionPayload[] | null {
+	if (!Array.isArray(input.questions)) return null;
+	const questions: AskQuestionPayload[] = [];
+	for (const question of input.questions) {
+		const parsedQuestion = parseAskQuestion(question);
+		if (parsedQuestion === undefined) return null;
+		questions.push(parsedQuestion);
+	}
+	return questions;
+}
+
+function getSessionMetadata(ctx: HookContext): SessionMetadata {
+	const header = ctx.sessionManager.getHeader();
+	return {
+		cwd: ctx.cwd,
+		sessionFile: ctx.sessionManager.getSessionFile() ?? undefined,
+		sessionName: parseNonEmptyString(header?.title),
+	};
+}
+
+async function dispatchNotification(ctx: HookContext, payload: NotificationPayload): Promise<void> {
+	try {
+		const config = await resolveHookNotificationConfig(ctx.cwd);
+		if (payload.event === "ask_waiting" && !config.notifyOnAsk) return;
+		if (payload.event === "completion" && !config.notifyOnCompletion) return;
+		await runHookNotification(config, payload);
+	} catch (error) {
+		logger.warn("Notification hook dispatch failed", {
+			event: payload.event,
+			error: error instanceof Error ? error.message : String(error),
+		});
+	}
+}
+
+function buildAskPayload(event: ToolCallEvent, ctx: HookContext): NotificationPayload | undefined {
+	if (event.toolName !== "ask") return undefined;
+	const questions = parseAskQuestions(event.input);
+	if (questions === null || questions.length === 0) return undefined;
+	return buildAskWaitingPayload({
+		...getSessionMetadata(ctx),
+		questions,
+	});
+}
+
+export default function notificationHooks(pi: HookAPI): void {
+	let completionRevision = 0;
+	let completionTimer: NodeJS.Timeout | undefined;
+	let sessionShuttingDown = false;
+
+	function cancelCompletionCandidate(): void {
+		completionRevision += 1;
+		if (completionTimer) {
+			clearTimeout(completionTimer);
+			completionTimer = undefined;
+		}
+	}
+
+	async function emitCompletionIfCurrent(ctx: HookContext, revision: number): Promise<void> {
+		if (sessionShuttingDown || revision !== completionRevision) return;
+		// Re-check current agent state at fire time because queued work can arrive
+		// after agent_end/auto_retry_end but before the deferred timer runs.
+		if (!ctx.isIdle() || ctx.hasQueuedMessages()) return;
+		await dispatchNotification(ctx, buildCompletionPayload(getSessionMetadata(ctx)));
+	}
+
+	function scheduleCompletionCandidate(ctx: HookContext): void {
+		if (sessionShuttingDown) return;
+		const revision = completionRevision + 1;
+		completionRevision = revision;
+		if (completionTimer) clearTimeout(completionTimer);
+		// Hooks await handler promises. Defer the completion candidate so retry or
+		// compaction follow-up events can cancel it without blocking the agent loop.
+		completionTimer = setTimeout(() => {
+			completionTimer = undefined;
+			void emitCompletionIfCurrent(ctx, revision);
+		}, 0);
+	}
+
+	function maybeRescheduleAfterCompaction(event: AutoCompactionEndEvent, ctx: HookContext): void {
+		if (event.willRetry) return;
+		if (!ctx.isIdle() || ctx.hasQueuedMessages()) return;
+		scheduleCompletionCandidate(ctx);
+	}
+
+	pi.on("tool_call", (event, ctx) => {
+		const payload = buildAskPayload(event, ctx);
+		if (payload) {
+			void dispatchNotification(ctx, payload);
+		}
+		return undefined;
+	});
+
+	pi.on("agent_end", (_event, ctx) => {
+		scheduleCompletionCandidate(ctx);
+	});
+
+	pi.on("auto_retry_start", () => {
+		cancelCompletionCandidate();
+	});
+
+	pi.on("auto_compaction_start", () => {
+		cancelCompletionCandidate();
+	});
+
+	pi.on("turn_start", () => {
+		cancelCompletionCandidate();
+	});
+
+	pi.on("auto_retry_end", (event, ctx) => {
+		if (!event.success) {
+			scheduleCompletionCandidate(ctx);
+		}
+	});
+
+	pi.on("auto_compaction_end", (event, ctx) => {
+		maybeRescheduleAfterCompaction(event, ctx);
+	});
+
+	pi.on("session_shutdown", () => {
+		sessionShuttingDown = true;
+		cancelCompletionCandidate();
+	});
+}

package/src/notify.ts

@@ -0,0 +1,88 @@
+import { logger } from "@oh-my-pi/pi-utils";
+import type { Subprocess } from "bun";
+import type { HookNotificationConfig } from "./config";
+import { buildNotificationEnv, type NotificationPayload } from "./payload";
+
+const payloadEncoder = new TextEncoder();
+
+function trimStderr(stderr: string): string | undefined {
+	const trimmed = stderr.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function safeKill(proc: Subprocess<"pipe", "ignore", "pipe">): void {
+	try {
+		proc.kill("SIGKILL");
+	} catch {
+		// Process already exited.
+	}
+}
+
+export async function runHookNotification(config: HookNotificationConfig, payload: NotificationPayload): Promise<void> {
+	if (config.command === null) return;
+
+	const payloadJson = JSON.stringify(payload);
+	const env = {
+		...Bun.env,
+		...buildNotificationEnv(payload),
+	};
+
+	try {
+		const proc = Bun.spawn([config.shell, "-lc", config.command], {
+			cwd: payload.cwd,
+			env,
+			stdin: "pipe",
+			stdout: "ignore",
+			stderr: "pipe",
+			windowsHide: true,
+		});
+		const stderrPromise = new Response(proc.stderr).text();
+		let timedOut = false;
+		const timeoutId = setTimeout(() => {
+			timedOut = true;
+			safeKill(proc);
+		}, config.timeoutMs);
+
+		try {
+			proc.stdin.write(payloadEncoder.encode(payloadJson));
+			proc.stdin.end();
+		} catch (error) {
+			clearTimeout(timeoutId);
+			safeKill(proc);
+			logger.warn("Notification hook stdin write failed", {
+				event: payload.event,
+				command: config.command,
+				error: error instanceof Error ? error.message : String(error),
+			});
+			return;
+		}
+
+		const [exitCode, stderr] = await Promise.all([proc.exited, stderrPromise]);
+		clearTimeout(timeoutId);
+
+		if (timedOut) {
+			logger.warn("Notification hook timed out", {
+				event: payload.event,
+				command: config.command,
+				timeoutMs: config.timeoutMs,
+				stderr: trimStderr(stderr),
+			});
+			return;
+		}
+
+		if (exitCode !== 0) {
+			logger.warn("Notification hook command failed", {
+				event: payload.event,
+				command: config.command,
+				exitCode,
+				stderr: trimStderr(stderr),
+			});
+		}
+	} catch (error) {
+		logger.warn("Notification hook spawn failed", {
+			event: payload.event,
+			command: config.command,
+			error: error instanceof Error ? error.message : String(error),
+		});
+	}
+}

package/src/payload.ts

@@ -0,0 +1,103 @@
+import type { NotificationEventType } from "./config";
+
+export interface AskQuestionPayload {
+	id: string;
+	question: string;
+	options: string[];
+	multi: boolean;
+	recommended?: number;
+}
+
+export interface NotificationPayload {
+	event: NotificationEventType;
+	message: string;
+	timestamp: number;
+	cwd: string;
+	session: { name?: string; file?: string };
+	toolName?: string;
+	ask?: { questionCount: number; questions: AskQuestionPayload[] };
+}
+
+interface AskWaitingPayloadInput {
+	cwd: string;
+	sessionName?: string;
+	sessionFile?: string;
+	questions: AskQuestionPayload[];
+	timestamp?: number;
+}
+
+interface CompletionPayloadInput {
+	cwd: string;
+	sessionName?: string;
+	sessionFile?: string;
+	timestamp?: number;
+}
+
+function buildSession(sessionName?: string, sessionFile?: string): NotificationPayload["session"] {
+	return {
+		name: sessionName,
+		file: sessionFile,
+	};
+}
+
+function buildMessage(prefix: string, sessionName?: string): string {
+	const trimmedName = sessionName?.trim();
+	return trimmedName ? `${trimmedName}: ${prefix}` : prefix;
+}
+
+function cloneQuestion(question: AskQuestionPayload): AskQuestionPayload {
+	return {
+		id: question.id,
+		question: question.question,
+		options: [...question.options],
+		multi: question.multi,
+		...(question.recommended === undefined ? {} : { recommended: question.recommended }),
+	};
+}
+
+function setEnvValue(env: Record<string, string>, key: string, value: string | number | undefined): void {
+	if (value === undefined) return;
+	env[key] = String(value);
+}
+
+export function buildNotificationEnv(payload: NotificationPayload): Record<string, string> {
+	const env: Record<string, string> = {
+		OMP_NOTIFY_EVENT: payload.event,
+		OMP_NOTIFY_MESSAGE: payload.message,
+		OMP_NOTIFY_CWD: payload.cwd,
+		OMP_NOTIFY_TIMESTAMP: String(payload.timestamp),
+	};
+
+	setEnvValue(env, "OMP_NOTIFY_SESSION_NAME", payload.session.name);
+	setEnvValue(env, "OMP_NOTIFY_SESSION_FILE", payload.session.file);
+	setEnvValue(env, "OMP_NOTIFY_TOOL_NAME", payload.toolName);
+	setEnvValue(env, "OMP_NOTIFY_QUESTION_COUNT", payload.ask?.questionCount);
+
+	return env;
+}
+
+export function buildAskWaitingPayload(input: AskWaitingPayloadInput): NotificationPayload {
+	const questions = input.questions.map(cloneQuestion);
+	return {
+		event: "ask_waiting",
+		message: buildMessage("Waiting for input", input.sessionName),
+		timestamp: input.timestamp ?? Date.now(),
+		cwd: input.cwd,
+		session: buildSession(input.sessionName, input.sessionFile),
+		toolName: "ask",
+		ask: {
+			questionCount: questions.length,
+			questions,
+		},
+	};
+}
+
+export function buildCompletionPayload(input: CompletionPayloadInput): NotificationPayload {
+	return {
+		event: "completion",
+		message: buildMessage("Complete", input.sessionName),
+		timestamp: input.timestamp ?? Date.now(),
+		cwd: input.cwd,
+		session: buildSession(input.sessionName, input.sessionFile),
+	};
+}