gsd-pi 0.3.0 → 0.3.3

package/src/resources/extensions/mcporter/index.ts

@@ -0,0 +1,410 @@
+/**
+ * MCPorter Extension — Lazy MCP server integration for pi
+ *
+ * Provides on-demand access to all MCP servers configured on the system
+ * (via Claude Desktop, Cursor, VS Code, mcporter config, etc.) without
+ * registering every tool upfront. This keeps token usage near-zero until
+ * the agent actually needs an MCP tool.
+ *
+ * Three tools:
+ *   mcp_servers   — List available MCP servers (cached after first call)
+ *   mcp_discover  — Get tool signatures for a specific server
+ *   mcp_call      — Call a tool on an MCP server
+ *
+ * Requirements:
+ *   - mcporter installed globally: npm i -g mcporter
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+	truncateHead,
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+} from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { execFile, exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const execAsync = promisify(exec);
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+interface McpServer {
+	name: string;
+	status: string;
+	transport?: string;
+	tools: { name: string; description: string }[];
+}
+
+interface McpListResponse {
+	mode: string;
+	counts: { ok: number; auth: number; offline: number; http: number; error: number };
+	servers: McpServer[];
+}
+
+interface McpToolSchema {
+	name: string;
+	description: string;
+	inputSchema?: Record<string, unknown>;
+}
+
+interface McpServerDetail {
+	name: string;
+	status: string;
+	tools: McpToolSchema[];
+}
+
+// ─── Cache ────────────────────────────────────────────────────────────────────
+
+let serverListCache: McpServer[] | null = null;
+const serverDetailCache = new Map<string, McpServerDetail>();
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+async function runMcporter(
+	args: string[],
+	signal?: AbortSignal,
+	timeoutMs = 30000,
+): Promise<string> {
+	// Use shell exec so PATH resolution works in all contexts
+	const escaped = args.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(" ");
+	const { stdout } = await execAsync(`mcporter ${escaped}`, {
+		timeout: timeoutMs,
+		maxBuffer: 1024 * 1024,
+		signal,
+		env: { ...process.env },
+	});
+	return stdout;
+}
+
+async function getServerList(signal?: AbortSignal): Promise<McpServer[]> {
+	if (serverListCache) return serverListCache;
+
+	const raw = await runMcporter(["list", "--json"], signal, 60000);
+	let data: McpListResponse;
+	try {
+		data = JSON.parse(raw) as McpListResponse;
+	} catch (e) {
+		throw new Error(`Failed to parse mcporter output: ${raw.slice(0, 300)}`);
+	}
+	if (!Array.isArray(data.servers)) {
+		throw new Error(`Unexpected mcporter response shape: ${JSON.stringify(Object.keys(data))}`);
+	}
+	serverListCache = data.servers;
+	return serverListCache;
+}
+
+async function getServerDetail(
+	serverName: string,
+	signal?: AbortSignal,
+): Promise<McpServerDetail> {
+	if (serverDetailCache.has(serverName)) return serverDetailCache.get(serverName)!;
+
+	const raw = await runMcporter(["list", serverName, "--schema", "--json"], signal);
+	const data = JSON.parse(raw) as McpServerDetail;
+	serverDetailCache.set(serverName, data);
+	return data;
+}
+
+function formatServerList(servers: McpServer[]): string {
+	if (servers.length === 0) return "No MCP servers found.";
+
+	const lines: string[] = [`${servers.length} MCP servers available:\n`];
+
+	for (const s of servers) {
+		const tools = s.tools ?? [];
+		const status = s.status === "ok" ? "✓" : s.status === "auth" ? "🔑" : "✗";
+		lines.push(`${status} ${s.name} — ${tools.length} tools (${s.status})`);
+		for (const t of tools) {
+			lines.push(`    ${t.name}: ${t.description?.slice(0, 100) ?? ""}`);
+		}
+	}
+
+	lines.push("\nUse mcp_discover to see full tool schemas for a specific server.");
+	lines.push("Use mcp_call to invoke a tool: mcp_call(server, tool, args).");
+	return lines.join("\n");
+}
+
+function formatServerDetail(detail: McpServerDetail): string {
+	const lines: string[] = [`${detail.name} — ${detail.tools.length} tools:\n`];
+
+	for (const tool of detail.tools) {
+		lines.push(`## ${tool.name}`);
+		if (tool.description) lines.push(tool.description);
+		if (tool.inputSchema) {
+			lines.push("```json");
+			lines.push(JSON.stringify(tool.inputSchema, null, 2));
+			lines.push("```");
+		}
+		lines.push("");
+	}
+
+	lines.push(`Call with: mcp_call(server="${detail.name}", tool="<tool_name>", args={...})`);
+	return lines.join("\n");
+}
+
+// ─── Extension ────────────────────────────────────────────────────────────────
+
+export default function (pi: ExtensionAPI) {
+	// ── mcp_servers ──────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_servers",
+		label: "MCP Servers",
+		description:
+			"List all available MCP servers discovered from your system (Claude Desktop, Cursor, VS Code, mcporter config). " +
+			"Shows server names, status, and tool counts. Use mcp_discover to get full tool schemas for a server.",
+		promptSnippet:
+			"List available MCP servers and their tools (lazy discovery via mcporter)",
+		promptGuidelines: [
+			"Call mcp_servers to see what MCP servers are available before trying to use one.",
+			"MCP servers provide external integrations (Twitter, Linear, Railway, etc.) via the Model Context Protocol.",
+			"After listing, use mcp_discover(server) to get tool schemas, then mcp_call(server, tool, args) to invoke.",
+		],
+		parameters: Type.Object({
+			refresh: Type.Optional(
+				Type.Boolean({ description: "Force refresh the server list (default: use cache)" }),
+			),
+		}),
+
+		async execute(_id, params, signal) {
+			if (params.refresh) serverListCache = null;
+
+			try {
+				const servers = await getServerList(signal);
+				return {
+					content: [{ type: "text", text: formatServerList(servers) }],
+					details: {
+						serverCount: servers.length,
+						cached: !params.refresh && serverListCache !== null,
+					},
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(
+					`Failed to list MCP servers. Is mcporter installed? (npm i -g mcporter)\n${msg}`,
+				);
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_servers"));
+			if (args.refresh) text += theme.fg("warning", " (refresh)");
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial }, theme) {
+			if (isPartial) return new Text(theme.fg("warning", "Discovering MCP servers..."), 0, 0);
+			const d = result.details as { serverCount: number } | undefined;
+			return new Text(
+				theme.fg("success", `${d?.serverCount ?? 0} servers found`),
+				0,
+				0,
+			);
+		},
+	});
+
+	// ── mcp_discover ─────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_discover",
+		label: "MCP Discover",
+		description:
+			"Get detailed tool signatures and JSON schemas for a specific MCP server. " +
+			"Use this to understand what tools a server provides and what arguments they accept " +
+			"before calling them with mcp_call.",
+		promptSnippet:
+			"Get tool schemas for a specific MCP server before calling its tools",
+		promptGuidelines: [
+			"Call mcp_discover with a server name to see the full tool signatures before calling mcp_call.",
+			"The schemas show required and optional parameters with types and descriptions.",
+		],
+		parameters: Type.Object({
+			server: Type.String({
+				description:
+					"MCP server name (from mcp_servers output), e.g. 'railway', 'twitter-mcp', 'linear'",
+			}),
+		}),
+
+		async execute(_id, params, signal) {
+			try {
+				const detail = await getServerDetail(params.server, signal);
+				const text = formatServerDetail(detail);
+
+				// Truncation guard
+				const truncation = truncateHead(text, {
+					maxLines: DEFAULT_MAX_LINES,
+					maxBytes: DEFAULT_MAX_BYTES,
+				});
+				let finalText = truncation.content;
+				if (truncation.truncated) {
+					finalText +=
+						`\n\n[Truncated: ${truncation.outputLines}/${truncation.totalLines} lines ` +
+						`(${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)})]`;
+				}
+
+				return {
+					content: [{ type: "text", text: finalText }],
+					details: {
+						server: params.server,
+						toolCount: detail.tools.length,
+						cached: serverDetailCache.has(params.server),
+					},
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(`Failed to discover tools for "${params.server}": ${msg}`);
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_discover "));
+			text += theme.fg("accent", args.server);
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial }, theme) {
+			if (isPartial)
+				return new Text(theme.fg("warning", "Discovering tools..."), 0, 0);
+			const d = result.details as { server: string; toolCount: number } | undefined;
+			return new Text(
+				theme.fg("success", `${d?.toolCount ?? 0} tools`) +
+					theme.fg("dim", ` · ${d?.server}`),
+				0,
+				0,
+			);
+		},
+	});
+
+	// ── mcp_call ─────────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_call",
+		label: "MCP Call",
+		description:
+			"Call a tool on an MCP server. Provide the server name, tool name, and arguments. " +
+			"Use mcp_discover first to see available tools and their required arguments.",
+		promptSnippet: "Call a tool on an MCP server via mcporter",
+		promptGuidelines: [
+			"Always use mcp_discover first to understand the tool's parameters before calling mcp_call.",
+			"Arguments are passed as a JSON object matching the tool's input schema.",
+		],
+		parameters: Type.Object({
+			server: Type.String({
+				description: "MCP server name, e.g. 'railway', 'twitter-mcp'",
+			}),
+			tool: Type.String({
+				description: "Tool name on that server, e.g. 'railway_list_projects'",
+			}),
+			args: Type.Optional(
+				Type.Record(Type.String(), Type.Unknown(), {
+					description:
+						"Tool arguments as key-value pairs matching the tool's input schema",
+				}),
+			),
+		}),
+
+		async execute(_id, params, signal) {
+			// Build mcporter call command: mcporter call server.tool key:value ...
+			const callTarget = `${params.server}.${params.tool}`;
+			const cliArgs = ["call", callTarget, "--output", "raw"];
+
+			if (params.args && Object.keys(params.args).length > 0) {
+				for (const [key, value] of Object.entries(params.args)) {
+					const strVal =
+						typeof value === "string" ? value : JSON.stringify(value);
+					cliArgs.push(`${key}:${strVal}`);
+				}
+			}
+
+			try {
+				const raw = await runMcporter(cliArgs, signal, 60000);
+
+				// Truncation guard
+				const truncation = truncateHead(raw, {
+					maxLines: DEFAULT_MAX_LINES,
+					maxBytes: DEFAULT_MAX_BYTES,
+				});
+				let finalText = truncation.content;
+				if (truncation.truncated) {
+					finalText +=
+						`\n\n[Output truncated: ${truncation.outputLines}/${truncation.totalLines} lines ` +
+						`(${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)})]`;
+				}
+
+				return {
+					content: [{ type: "text", text: finalText }],
+					details: {
+						server: params.server,
+						tool: params.tool,
+						charCount: finalText.length,
+						truncated: truncation.truncated,
+					},
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(
+					`MCP call failed: ${params.server}.${params.tool}\n${msg}`,
+				);
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_call "));
+			text += theme.fg("accent", `${args.server}.${args.tool}`);
+			if (args.args && Object.keys(args.args).length > 0) {
+				const preview = Object.entries(args.args)
+					.slice(0, 3)
+					.map(([k, v]) => {
+						const val = typeof v === "string" ? v : JSON.stringify(v);
+						return `${k}:${val.length > 30 ? val.slice(0, 30) + "…" : val}`;
+					})
+					.join(" ");
+				text += " " + theme.fg("muted", preview);
+			}
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial, expanded }, theme) {
+			if (isPartial) return new Text(theme.fg("warning", "Calling MCP tool..."), 0, 0);
+
+			const d = result.details as {
+				server: string;
+				tool: string;
+				charCount: number;
+				truncated: boolean;
+			} | undefined;
+
+			let text = theme.fg("success", `✓ ${d?.server}.${d?.tool}`);
+			text += theme.fg("dim", ` · ${(d?.charCount ?? 0).toLocaleString()} chars`);
+			if (d?.truncated) text += theme.fg("warning", " · truncated");
+
+			if (expanded) {
+				const content = result.content[0];
+				if (content?.type === "text") {
+					const preview = content.text.split("\n").slice(0, 15).join("\n");
+					text += "\n\n" + theme.fg("dim", preview);
+				}
+			}
+
+			return new Text(text, 0, 0);
+		},
+	});
+
+	// ── Verify mcporter is available ─────────────────────────────────────────
+
+	pi.on("session_start", async (_event, ctx) => {
+		try {
+			const ver = (await runMcporter(["--version"], undefined, 5000)).trim();
+		ctx.ui.notify(`MCPorter ${ver} ready`, "info");
+		} catch {
+			ctx.ui.notify(
+				"MCPorter not found. Install with: npm i -g mcporter",
+				"error",
+			);
+		}
+	});
+}

package/src/resources/extensions/slash-commands/clear.ts

@@ -0,0 +1,10 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+
+export default function clearCommand(pi: ExtensionAPI) {
+  pi.registerCommand("clear", {
+    description: "Alias for /new — start a new session",
+    async handler(_args: string, ctx: ExtensionCommandContext) {
+      await ctx.newSession();
+    },
+  });
+}

package/src/resources/extensions/slash-commands/index.ts

@@ -2,11 +2,11 @@ import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import createSlashCommand from "./create-slash-command.js";
 import createExtension from "./create-extension.js";
 import auditCommand from "./audit.js";
-import gsdRun from "./gsd-run.js";
+import clearCommand from "./clear.js";
 
 export default function slashCommands(pi: ExtensionAPI) {
   createSlashCommand(pi);
   createExtension(pi);
   auditCommand(pi);
-  gsdRun(pi);
+  clearCommand(pi);
 }

package/src/resources/extensions/voice/index.ts

@@ -0,0 +1,176 @@
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { AssistantMessage } from "@mariozechner/pi-ai";
+import { isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { spawn, type ChildProcess } from "node:child_process";
+import * as path from "node:path";
+import * as readline from "node:readline";
+
+const RECOGNIZER_BIN = path.join(__dirname, "speech-recognizer");
+
+export default function (pi: ExtensionAPI) {
+	if (process.platform !== "darwin") return;
+
+	let active = false;
+	let recognizerProcess: ChildProcess | null = null;
+	let finalized = "";
+	let flashOn = true;
+	let flashTimer: ReturnType<typeof setInterval> | null = null;
+	let footerTui: { requestRender: () => void } | null = null;
+
+	function setVoiceFooter(ctx: ExtensionContext, on: boolean) {
+		if (!on) {
+			stopFlash();
+			ctx.ui.setFooter(undefined);
+			return;
+		}
+
+		flashOn = true;
+		flashTimer = setInterval(() => {
+			flashOn = !flashOn;
+			footerTui?.requestRender();
+		}, 500);
+
+		ctx.ui.setFooter((tui, theme, footerData) => {
+			footerTui = tui;
+			const branchUnsub = footerData.onBranchChange(() => tui.requestRender());
+
+			return {
+				dispose: branchUnsub,
+				invalidate() {},
+				render(width: number): string[] {
+					// --- Row 1: pwd (branch) ... ● transcribing ---
+					let pwd = process.cwd();
+					const home = process.env.HOME || process.env.USERPROFILE;
+					if (home && pwd.startsWith(home)) pwd = `~${pwd.slice(home.length)}`;
+					const branch = footerData.getGitBranch();
+					if (branch) pwd = `${pwd} (${branch})`;
+
+					const dot = flashOn ? theme.fg("error", "●") : theme.fg("dim", "●");
+					const voiceTag = `${dot} ${theme.fg("error", "transcribing")}`;
+					const voiceTagWidth = visibleWidth(voiceTag);
+
+					const maxPwdWidth = width - voiceTagWidth - 2;
+					const pwdStr = truncateToWidth(theme.fg("dim", pwd), maxPwdWidth, theme.fg("dim", "..."));
+					const pad1 = " ".repeat(Math.max(1, width - visibleWidth(pwdStr) - voiceTagWidth));
+					const row1 = truncateToWidth(pwdStr + pad1 + voiceTag, width);
+
+					// --- Row 2: stats ... model (replicate default) ---
+					let totalInput = 0, totalOutput = 0, totalCost = 0;
+					for (const entry of ctx.sessionManager.getEntries()) {
+						if (entry.type === "message" && entry.message.role === "assistant") {
+							const m = entry.message as AssistantMessage;
+							totalInput += m.usage.input;
+							totalOutput += m.usage.output;
+							totalCost += m.usage.cost.total;
+						}
+					}
+
+					const fmt = (n: number) => n < 1000 ? `${n}` : n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
+					const parts: string[] = [];
+					if (totalInput) parts.push(`↑${fmt(totalInput)}`);
+					if (totalOutput) parts.push(`↓${fmt(totalOutput)}`);
+					if (totalCost) parts.push(`$${totalCost.toFixed(3)}`);
+
+					const usage = ctx.getContextUsage();
+					const ctxPct = usage?.percent !== null && usage?.percent !== undefined ? `${usage.percent.toFixed(1)}%` : "?";
+					const ctxWin = usage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
+					parts.push(`${ctxPct}/${fmt(ctxWin)}`);
+
+					const statsLeft = theme.fg("dim", parts.join(" "));
+					const modelRight = theme.fg("dim", ctx.model?.id || "no-model");
+					const statsLeftW = visibleWidth(statsLeft);
+					const modelRightW = visibleWidth(modelRight);
+					const pad2 = " ".repeat(Math.max(2, width - statsLeftW - modelRightW));
+					const row2 = truncateToWidth(statsLeft + pad2 + modelRight, width);
+
+					return [row1, row2];
+				},
+			};
+		});
+	}
+
+	function stopFlash() {
+		if (flashTimer) { clearInterval(flashTimer); flashTimer = null; }
+		footerTui = null;
+	}
+
+	async function toggleVoice(ctx: ExtensionContext) {
+		if (active) {
+			killRecognizer();
+			active = false;
+			setVoiceFooter(ctx, false);
+			return;
+		}
+
+		active = true;
+		finalized = "";
+		setVoiceFooter(ctx, true);
+		await runVoiceSession(ctx);
+	}
+
+	pi.registerCommand("voice", {
+		description: "Toggle voice mode",
+		handler: async (_args, ctx) => toggleVoice(ctx),
+	});
+
+	pi.registerShortcut("ctrl+alt+v", {
+		description: "Toggle voice mode",
+		handler: async (ctx) => toggleVoice(ctx),
+	});
+
+	function killRecognizer() {
+		if (recognizerProcess) { recognizerProcess.kill("SIGTERM"); recognizerProcess = null; }
+	}
+
+	function startRecognizer(
+		onPartial: (text: string) => void,
+		onFinal: (text: string) => void,
+		onError: (msg: string) => void,
+		onReady: () => void,
+	) {
+		recognizerProcess = spawn(RECOGNIZER_BIN, [], { stdio: ["pipe", "pipe", "pipe"] });
+		const rl = readline.createInterface({ input: recognizerProcess.stdout! });
+		rl.on("line", (line: string) => {
+			if (line === "READY") { onReady(); return; }
+			if (line.startsWith("PARTIAL:")) onPartial(line.slice(8));
+			else if (line.startsWith("FINAL:")) onFinal(line.slice(6));
+			else if (line.startsWith("ERROR:")) onError(line.slice(6));
+		});
+		recognizerProcess.on("error", (err) => onError(err.message));
+		recognizerProcess.on("exit", () => { recognizerProcess = null; });
+	}
+
+	async function runVoiceSession(ctx: ExtensionContext): Promise<void> {
+		return new Promise<void>((resolve) => {
+			startRecognizer(
+				(text) => {
+					const full = finalized + (finalized && text ? " " : "") + text;
+					ctx.ui.setEditorText(full);
+				},
+				(text) => {
+					finalized = (finalized ? finalized + " " : "") + text;
+					ctx.ui.setEditorText(finalized);
+				},
+				(msg) => ctx.ui.notify(`Voice: ${msg}`, "error"),
+				() => {},
+			);
+
+			ctx.ui.custom<void>(
+				(_tui, _theme, _kb, done) => ({
+					render(): string[] { return []; },
+					handleInput(data: string) {
+						if (isKeyRelease(data)) return;
+						if (matchesKey(data, Key.escape) || matchesKey(data, Key.enter)) {
+							killRecognizer();
+							active = false;
+							setVoiceFooter(ctx, false);
+							done();
+						}
+					},
+					invalidate() {},
+				}),
+				{ overlay: true, overlayOptions: { anchor: "bottom-center", width: "100%" } },
+			).then(() => resolve());
+		});
+	}
+}

package/src/resources/extensions/voice/speech-recognizer.swift

@@ -0,0 +1,76 @@
+import Foundation
+import Speech
+import AVFoundation
+
+// Unbuffered stdout
+setbuf(stdout, nil)
+
+guard SFSpeechRecognizer.authorizationStatus() == .authorized ||
+      SFSpeechRecognizer.authorizationStatus() == .notDetermined else {
+    print("ERROR:Speech recognition not authorized")
+    exit(1)
+}
+
+SFSpeechRecognizer.requestAuthorization { status in
+    guard status == .authorized else {
+        print("ERROR:Speech recognition denied")
+        exit(1)
+    }
+}
+
+let recognizer = SFSpeechRecognizer(locale: Locale(identifier: "en-US"))!
+guard recognizer.isAvailable else {
+    print("ERROR:Speech recognizer not available")
+    exit(1)
+}
+
+let audioEngine = AVAudioEngine()
+let request = SFSpeechAudioBufferRecognitionRequest()
+request.shouldReportPartialResults = true
+request.requiresOnDeviceRecognition = true
+
+let node = audioEngine.inputNode
+let format = node.outputFormat(forBus: 0)
+
+node.installTap(onBus: 0, bufferSize: 1024, format: format) { buffer, _ in
+    request.append(buffer)
+}
+
+audioEngine.prepare()
+do {
+    try audioEngine.start()
+    print("READY")
+} catch {
+    print("ERROR:Failed to start audio engine: \(error.localizedDescription)")
+    exit(1)
+}
+
+var lastText = ""
+
+recognizer.recognitionTask(with: request) { result, error in
+    if let result = result {
+        let text = result.bestTranscription.formattedString
+        if text != lastText {
+            lastText = text
+            let prefix = result.isFinal ? "FINAL" : "PARTIAL"
+            print("\(prefix):\(text)")
+        }
+    }
+    if let error = error {
+        // Task finished errors are normal on kill
+        let nsError = error as NSError
+        if nsError.code != 216 { // kAFAssistantErrorDomain code for cancelled
+            print("ERROR:\(error.localizedDescription)")
+        }
+    }
+}
+
+// Handle SIGTERM/SIGINT gracefully
+signal(SIGTERM) { _ in
+    exit(0)
+}
+signal(SIGINT) { _ in
+    exit(0)
+}
+
+RunLoop.current.run()