@ai-agent-forge/agent-forge 0.85.0

package/examples/extensions/tool-override/index.ts

@@ -0,0 +1,159 @@
+/**
+ * Tool Override Example - Demonstrates overriding built-in tools
+ *
+ * Extensions can register tools with the same name as built-in tools to replace them.
+ * This is useful for:
+ * - Adding logging or auditing to tool calls
+ * - Implementing access control or sandboxing
+ * - Routing tool calls to remote systems (e.g., pi-ssh-remote)
+ * - Modifying tool behavior for specific workflows
+ *
+ * This example overrides the `read` tool to:
+ * 1. Log all file access to a log file
+ * 2. Block access to sensitive paths (e.g., .env files)
+ * 3. Delegate to the original read implementation for allowed files
+ *
+ * Since no custom renderCall/renderResult are provided, the built-in renderer
+ * is used automatically (syntax highlighting, line numbers, truncation warnings).
+ *
+ * Usage:
+ *   Copy this directory (with plugin.json) to ~/.agent-forge/agent/plugins
+ *   or <cwd>/.agent-forge/plugins for auto-discovery.
+ *
+ * Migrated to the capability plugin form (D-056 tool-surface batch, 2026-09-21):
+ * the same-name read override rides the capability replacement contract (last
+ * load wins, restore on dispose); the execute `ctx.cwd` maps to the context
+ * parameter and `ctx.ui.notify` maps to `api.interaction?.notify`.
+ */
+
+import { type CapabilityAPI, defineTool, getAgentDir, withFileMutationQueue } from "@agent-forge/agent-forge";
+import type { TextContent } from "@agent-forge/ai";
+import { constants, readFileSync } from "fs";
+import { access, appendFile, readFile } from "fs/promises";
+import { join, resolve } from "path";
+import { Type } from "typebox";
+
+const LOG_FILE = join(getAgentDir(), "read-access.log");
+
+// Paths that are blocked from reading
+const BLOCKED_PATTERNS = [
+	/\.env$/,
+	/\.env\..+$/,
+	/secrets?\.(json|yaml|yml|toml)$/i,
+	/credentials?\.(json|yaml|yml|toml)$/i,
+	/\/\.ssh\//,
+	/\/\.aws\//,
+	/\/\.gnupg\//,
+];
+
+function isBlockedPath(path: string): boolean {
+	return BLOCKED_PATTERNS.some((pattern) => pattern.test(path));
+}
+
+async function logAccess(path: string, allowed: boolean, reason?: string) {
+	const timestamp = new Date().toISOString();
+	const status = allowed ? "ALLOWED" : "BLOCKED";
+	const msg = reason ? ` (${reason})` : "";
+	const line = `[${timestamp}] ${status}: ${path}${msg}\n`;
+
+	try {
+		await withFileMutationQueue(LOG_FILE, async () => {
+			await appendFile(LOG_FILE, line);
+		});
+	} catch {
+		// Ignore logging errors
+	}
+}
+
+const readSchema = Type.Object({
+	path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
+	offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
+	limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
+});
+
+export default function (api: CapabilityAPI) {
+	api.registerTool(
+		defineTool({
+			name: "read", // Same name as built-in - this will override it
+			label: "read (audited)",
+			description:
+				"Read the contents of a file with access logging. Some sensitive paths (.env, secrets, credentials) are blocked.",
+			parameters: readSchema,
+
+			async execute(_toolCallId, params, _signal, _onUpdate, context) {
+				const { path, offset, limit } = params;
+				const absolutePath = resolve(context?.cwd ?? process.cwd(), path);
+
+				// Check if path is blocked
+				if (isBlockedPath(absolutePath)) {
+					await logAccess(absolutePath, false, "matches blocked pattern");
+					return {
+						content: [
+							{
+								type: "text",
+								text: `Access denied: "${path}" matches a blocked pattern (sensitive file). This tool blocks access to .env files, secrets, credentials, and SSH/AWS/GPG directories.`,
+							},
+						],
+						details: { blocked: true },
+					};
+				}
+
+				// Log allowed access
+				await logAccess(absolutePath, true);
+
+				// Perform the actual read (simplified implementation)
+				try {
+					await access(absolutePath, constants.R_OK);
+					const content = await readFile(absolutePath, "utf-8");
+					const lines = content.split("\n");
+
+					// Apply offset and limit
+					const startLine = offset ? Math.max(0, offset - 1) : 0;
+					const endLine = limit ? startLine + limit : lines.length;
+					const selectedLines = lines.slice(startLine, endLine);
+
+					// Basic truncation (50KB limit)
+					let text = selectedLines.join("\n");
+					const maxBytes = 50 * 1024;
+					if (Buffer.byteLength(text, "utf-8") > maxBytes) {
+						text = `${text.slice(0, maxBytes)}\n\n[Output truncated at 50KB]`;
+					}
+
+					return {
+						content: [{ type: "text", text }] as TextContent[],
+						details: { lines: lines.length },
+					};
+				} catch (error) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: `Error reading file: ${error instanceof Error ? error.message : String(error)}`,
+							},
+						] as TextContent[],
+						details: { error: true },
+					};
+				}
+			},
+
+			// No renderCall/renderResult - uses built-in renderer automatically
+			// (syntax highlighting, line numbers, truncation warnings, etc.)
+		}),
+	);
+
+	// Also register a command to view the access log
+	api.registerCommand({
+		name: "read-log",
+		description: "View the file access log",
+		execute: async () => {
+			try {
+				const log = readFileSync(LOG_FILE, "utf-8");
+				const lines = log.trim().split("\n").slice(-20); // Last 20 entries
+				api.interaction?.notify({ message: `Recent file access:\n${lines.join("\n")}`, level: "info" });
+			} catch {
+				api.interaction?.notify({ message: "No access log found", level: "info" });
+			}
+			return undefined;
+		},
+	});
+}

package/examples/extensions/tool-override/plugin.json

@@ -0,0 +1,11 @@
+{
+  "id": "agent-forge.example.tool-override",
+  "version": "0.1.0",
+  "hostVersion": ">=0.84.0",
+  "apiVersion": "1-draft",
+  "entry": "./index.ts",
+  "requiredCapabilities": [
+    "tools",
+    "commands"
+  ]
+}

package/examples/extensions/trigger-compact/index.ts

@@ -0,0 +1,76 @@
+/**
+ * Trigger compaction example (capability plugin form).
+ *
+ * Auto-compacts once context usage crosses 100k tokens between two turns, and
+ * adds `/trigger-compact` for an immediate, manual compaction.
+ *
+ * Usage: /trigger-compact [instructions] - trigger compaction immediately
+ *
+ * Install: copy this directory (with plugin.json) to ~/.agent-forge/agent/plugins
+ * or <cwd>/.agent-forge/plugins for auto-discovery.
+ *
+ * Migrated to the capability plugin form (D-056 session-surface batch, 2026-09-21):
+ * `pi.on("turn_end")` maps to `api.lifecycle.registerObserve("turn.end", handler, 1)`
+ * (the catalog's TURN_END_EVENT_ID/TURN_END_EVENT_VERSION pair; the observation is
+ * the only registration kind the event allows), `ctx.getContextUsage()` to
+ * `SessionAPI.getContextUsage?()` (host-measured || `undefined` when unavailable),
+ * `ctx.compact(options)` to `SessionAPI.compact?(customInstructions)` — the same
+ * `AgentSession.compact` promise the legacy `compact` action wrapped — with the
+ * `onComplete`/`onError` callbacks expressed as the promise's two outcomes, and
+ * `ctx.hasUI` + `ctx.ui.notify` to the optional `api.interaction` surface.
+ *
+ * Error text stays `Compaction failed: <message>`: the legacy wiring normalized a
+ * non-Error rejection to `new Error(String(cause))` before calling `onError`
+ * (agent-session-extensions.ts), so the message is normalized the same way here.
+ */
+
+import type { CapabilityAPI } from "@agent-forge/agent-forge";
+
+const COMPACT_THRESHOLD_TOKENS = 100_000;
+
+export default function triggerCompactExample(api: CapabilityAPI): void {
+	let previousTokens: number | null | undefined;
+
+	const triggerCompaction = (customInstructions?: string) => {
+		api.interaction?.notify({ message: "Compaction started", level: "info" });
+		void api.session?.compact?.(customInstructions)?.then(
+			() => {
+				api.interaction?.notify({ message: "Compaction completed", level: "info" });
+			},
+			(error: unknown) => {
+				const message = error instanceof Error ? error.message : String(error);
+				api.interaction?.notify({ message: `Compaction failed: ${message}`, level: "error" });
+			},
+		);
+	};
+
+	api.lifecycle.registerObserve(
+		"turn.end",
+		() => {
+			const usage = api.session?.getContextUsage?.();
+			const currentTokens = usage?.tokens ?? null;
+			if (currentTokens === null) {
+				return;
+			}
+
+			const crossedThreshold =
+				previousTokens !== undefined && previousTokens !== null && previousTokens <= COMPACT_THRESHOLD_TOKENS;
+			previousTokens = currentTokens;
+			if (!crossedThreshold || currentTokens <= COMPACT_THRESHOLD_TOKENS) {
+				return;
+			}
+			triggerCompaction();
+		},
+		1,
+	);
+
+	api.registerCommand({
+		name: "trigger-compact",
+		description: "Trigger compaction immediately",
+		execute: (args) => {
+			const instructions = args.trim() || undefined;
+			triggerCompaction(instructions);
+			return undefined;
+		},
+	});
+}

package/examples/extensions/trigger-compact/plugin.json

@@ -0,0 +1,14 @@
+{
+  "id": "agent-forge.example.trigger-compact",
+  "version": "0.1.0",
+  "hostVersion": ">=0.84.0",
+  "apiVersion": "1-draft",
+  "entry": "./index.ts",
+  "requiredCapabilities": [
+    "commands",
+    "session"
+  ],
+  "optionalCapabilities": [
+    "interaction"
+  ]
+}

package/examples/extensions/truncated-tool/index.ts

@@ -0,0 +1,204 @@
+/**
+ * Truncated Tool Example - Demonstrates proper output truncation for custom tools
+ * (capability plugin form)
+ *
+ * Custom tools MUST truncate their output to avoid overwhelming the LLM context.
+ * The built-in limit is 50KB (~10k tokens) and 2000 lines, whichever is hit first.
+ *
+ * This example shows how to:
+ * 1. Use the built-in truncation utilities
+ * 2. Write full output to a temp file when truncated
+ * 3. Inform the LLM where to find the complete output
+ * 4. Custom rendering of tool calls and results
+ *
+ * The `rg` tool here wraps ripgrep with proper truncation. Compare this to the
+ * built-in `grep` tool in src/core/tools/grep.ts for a more complete implementation.
+ *
+ * Install: copy this directory (with plugin.json) to ~/.agent-forge/agent/plugins
+ * or <cwd>/.agent-forge/plugins for auto-discovery.
+ */
+
+import { mkdtemp, writeFile } from "node:fs/promises";
+import type { CapabilityAPI, ToolDefinition } from "@agent-forge/agent-forge";
+import {
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+	type TruncationResult,
+	truncateHead,
+	withFileMutationQueue,
+} from "@agent-forge/agent-forge";
+import { Text } from "@agent-forge/tui";
+import { execSync } from "child_process";
+import { tmpdir } from "os";
+import { join } from "path";
+import { Type } from "typebox";
+
+const RgParams = Type.Object({
+	pattern: Type.String({ description: "Search pattern (regex)" }),
+	path: Type.Optional(Type.String({ description: "Directory to search (default: current directory)" })),
+	glob: Type.Optional(Type.String({ description: "File glob pattern, e.g. '*.ts'" })),
+});
+
+interface RgDetails {
+	pattern: string;
+	path?: string;
+	glob?: string;
+	matchCount: number;
+	truncation?: TruncationResult;
+	fullOutputPath?: string;
+}
+
+// Typed as ToolDefinition explicitly: the capability registerTool takes the
+// definition as `unknown`, so the object literal no longer gets contextual
+// parameter types from the legacy registerTool signature.
+const rgTool: ToolDefinition<typeof RgParams, RgDetails> = {
+	name: "rg",
+	label: "ripgrep",
+	// Document the truncation limits in the tool description so the LLM knows
+	description: `Search file contents using ripgrep. Output is truncated to ${DEFAULT_MAX_LINES} lines or ${formatSize(DEFAULT_MAX_BYTES)} (whichever is hit first). If truncated, full output is saved to a temp file.`,
+	parameters: RgParams,
+
+	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		const { pattern, path: searchPath, glob } = params;
+
+		// Build the ripgrep command
+		const args = ["rg", "--line-number", "--color=never"];
+		if (glob) args.push("--glob", glob);
+		args.push(pattern);
+		args.push(searchPath || ".");
+
+		let output: string;
+		try {
+			output = execSync(args.join(" "), {
+				cwd: ctx.cwd,
+				encoding: "utf-8",
+				maxBuffer: 100 * 1024 * 1024, // 100MB buffer to capture full output
+			});
+		} catch (err) {
+			// ripgrep exits with 1 when no matches found
+			if ((err as { status?: unknown }).status === 1) {
+				return {
+					content: [{ type: "text", text: "No matches found" }],
+					details: { pattern, path: searchPath, glob, matchCount: 0 } as RgDetails,
+				};
+			}
+			throw new Error(`ripgrep failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+
+		if (!output.trim()) {
+			return {
+				content: [{ type: "text", text: "No matches found" }],
+				details: { pattern, path: searchPath, glob, matchCount: 0 } as RgDetails,
+			};
+		}
+
+		// Apply truncation using built-in utilities
+		// truncateHead keeps the first N lines/bytes (good for search results)
+		// truncateTail keeps the last N lines/bytes (good for logs/command output)
+		const truncation = truncateHead(output, {
+			maxLines: DEFAULT_MAX_LINES,
+			maxBytes: DEFAULT_MAX_BYTES,
+		});
+
+		// Count matches (each non-empty line with a match)
+		const matchCount = output.split("\n").filter((line) => line.trim()).length;
+
+		const details: RgDetails = {
+			pattern,
+			path: searchPath,
+			glob,
+			matchCount,
+		};
+
+		let resultText = truncation.content;
+
+		if (truncation.truncated) {
+			// Save full output to a temp file so LLM can access it if needed
+			const tempDir = await mkdtemp(join(tmpdir(), "pi-rg-"));
+			const tempFile = join(tempDir, "output.txt");
+			await withFileMutationQueue(tempFile, async () => {
+				await writeFile(tempFile, output, "utf8");
+			});
+
+			details.truncation = truncation;
+			details.fullOutputPath = tempFile;
+
+			// Add truncation notice - this helps the LLM understand the output is incomplete
+			const truncatedLines = truncation.totalLines - truncation.outputLines;
+			const truncatedBytes = truncation.totalBytes - truncation.outputBytes;
+
+			resultText += `\n\n[Output truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`;
+			resultText += ` (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}).`;
+			resultText += ` ${truncatedLines} lines (${formatSize(truncatedBytes)}) omitted.`;
+			resultText += ` Full output saved to: ${tempFile}]`;
+		}
+
+		return {
+			content: [{ type: "text", text: resultText }],
+			details,
+		};
+	},
+
+	// Custom rendering of the tool call (shown before/during execution)
+	renderCall(args, theme, _context) {
+		let text = theme.fg("toolTitle", theme.bold("rg "));
+		text += theme.fg("accent", `"${args.pattern}"`);
+		if (args.path) {
+			text += theme.fg("muted", ` in ${args.path}`);
+		}
+		if (args.glob) {
+			text += theme.fg("dim", ` --glob ${args.glob}`);
+		}
+		return new Text(text, 0, 0);
+	},
+
+	// Custom rendering of the tool result
+	renderResult(result, { expanded, isPartial }, theme, _context) {
+		const details = result.details as RgDetails | undefined;
+
+		// Handle streaming/partial results
+		if (isPartial) {
+			return new Text(theme.fg("warning", "Searching..."), 0, 0);
+		}
+
+		// No matches
+		if (!details || details.matchCount === 0) {
+			return new Text(theme.fg("dim", "No matches found"), 0, 0);
+		}
+
+		// Build result display
+		let text = theme.fg("success", `${details.matchCount} matches`);
+
+		// Show truncation warning if applicable
+		if (details.truncation?.truncated) {
+			text += theme.fg("warning", " (truncated)");
+		}
+
+		// In expanded view, show the actual matches
+		if (expanded) {
+			const content = result.content[0];
+			if (content?.type === "text") {
+				// Show first 20 lines in expanded view, or all if fewer
+				const lines = content.text.split("\n").slice(0, 20);
+				for (const line of lines) {
+					text += `\n${theme.fg("dim", line)}`;
+				}
+				if (content.text.split("\n").length > 20) {
+					text += `\n${theme.fg("muted", "... (use read tool to see full output)")}`;
+				}
+			}
+
+			// Show temp file path if truncated
+			if (details.fullOutputPath) {
+				text += `\n${theme.fg("dim", `Full output: ${details.fullOutputPath}`)}`;
+			}
+		}
+
+		return new Text(text, 0, 0);
+	},
+};
+
+export default function truncatedToolExample(api: CapabilityAPI): void {
+	api.registerTool(rgTool);
+}

package/examples/extensions/truncated-tool/plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "agent-forge.example.truncated-tool",
+  "version": "0.1.0",
+  "hostVersion": ">=0.84.0",
+  "apiVersion": "1-draft",
+  "entry": "./index.ts",
+  "requiredCapabilities": [
+    "tools"
+  ]
+}

package/examples/extensions/with-deps/index.ts

@@ -0,0 +1,42 @@
+/**
+ * Example extension with its own npm dependencies (capability plugin form).
+ * Tests that the loader (jiti) resolves modules from the extension's own
+ * node_modules.
+ *
+ * Requires: npm install in this directory
+ *
+ * The manifest is `plugin.json` (below the legacy `package.json` "pi" block,
+ * which is unused by the capability loader). The `ms` dependency itself is
+ * unchanged; the only moved line is the registration face
+ * (`pi.registerTool` -> `api.registerTool`).
+ *
+ * Install: copy this directory (with plugin.json) to ~/.agent-forge/agent/plugins
+ * or <cwd>/.agent-forge/plugins for auto-discovery.
+ */
+
+import { type CapabilityAPI, defineTool } from "@agent-forge/agent-forge";
+import ms from "ms";
+import { Type } from "typebox";
+
+const parseDurationTool = defineTool({
+	name: "parse_duration",
+	label: "Parse Duration",
+	description: "Parse a human-readable duration string (e.g., '2 days', '1h', '5m') to milliseconds",
+	parameters: Type.Object({
+		duration: Type.String({ description: "Duration string like '2 days', '1h', '5m'" }),
+	}),
+	execute: async (_toolCallId, params) => {
+		const result = ms(params.duration as ms.StringValue);
+		if (result === undefined) {
+			throw new Error(`Invalid duration: "${params.duration}"`);
+		}
+		return {
+			content: [{ type: "text", text: `${params.duration} = ${result} milliseconds` }],
+			details: {},
+		};
+	},
+});
+
+export default function withDepsExample(api: CapabilityAPI): void {
+	api.registerTool(parseDurationTool);
+}

package/examples/extensions/with-deps/package-lock.json

@@ -0,0 +1,31 @@
+{
+  "name": "agent-forge-extension-with-deps",
+  "version": "0.85.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "agent-forge-extension-with-deps",
+      "version": "0.85.0",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "devDependencies": {
+        "@types/ms": "^2.1.0"
+      }
+    },
+    "node_modules/@types/ms": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+      "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    }
+  }
+}

package/examples/extensions/with-deps/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "agent-forge-extension-with-deps",
+  "private": true,
+  "version": "0.85.0",
+  "type": "module",
+  "scripts": {
+    "clean": "echo 'nothing to clean'",
+    "build": "echo 'nothing to build'",
+    "check": "echo 'nothing to check'"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "dependencies": {
+    "ms": "2.1.3"
+  },
+  "devDependencies": {
+    "@types/ms": "2.1.0"
+  }
+}

package/examples/extensions/with-deps/plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "agent-forge.example.with-deps",
+  "version": "0.1.0",
+  "hostVersion": ">=0.84.0",
+  "apiVersion": "1-draft",
+  "entry": "./index.ts",
+  "requiredCapabilities": [
+    "tools"
+  ]
+}

package/examples/remote-client.ts

@@ -0,0 +1,66 @@
+/**
+ * Remote server + client end-to-end example (experimental, single-user local trust).
+ *
+ * Starts a coding-agent remote server on an ephemeral loopback TCP port,
+ * connects with the @agent-forge/client TCP transport, creates a session,
+ * subscribes to snapshots, runs one prompt, then shuts everything down.
+ *
+ * Trust boundary: the server has no default authentication and accepts any
+ * cwd a client submits, so any local process could drive the agent. Only run
+ * it in a single-user local-trust environment. Opt in to a create-cwd
+ * boundary via `--serve-workspace-root` (CLI) or `workspaceRoots`
+ * (sessionSourceOptions) when needed.
+ *
+ * Run: cd packages/agent-forge && npx tsx examples/remote-client.ts
+ * The prompt requires configured provider auth in the agent dir
+ * (~/.agent-forge/agent), just like the SDK examples.
+ */
+
+import { getAgentDir, getSessionsDir, startCodingAgentRemoteServer } from "@agent-forge/agent-forge";
+import { PiClient } from "@agent-forge/client";
+import { createTcpTransportFactory } from "@agent-forge/client/tcp";
+import { createTcpServerListener } from "@agent-forge/server";
+
+// Port 0 selects an ephemeral port; the listener binds loopback by default.
+const server = await startCodingAgentRemoteServer({
+	sessionSourceOptions: {
+		sessionsDir: getSessionsDir(),
+		cwd: process.cwd(),
+		agentDir: getAgentDir(),
+	},
+	listeners: [createTcpServerListener({ port: 0 })],
+});
+
+const address = server.addresses[0] ?? "";
+const port = Number.parseInt(address.slice(address.lastIndexOf(":") + 1), 10);
+console.log(`Remote server listening on ${address}`);
+
+const client = new PiClient({
+	transportFactory: createTcpTransportFactory({ host: "127.0.0.1", port }),
+	// A remote prompt is a full agent turn and can outlast the five-minute
+	// client default; raise it for longer turns, or set 0 to disable timeouts.
+	requestTimeoutMs: 600_000,
+});
+
+try {
+	await client.connect();
+
+	// createSession() returns an exclusive SessionLease; attachSession(id)
+	// re-opens an existing session in shared mode.
+	const session = await client.createSession({ cwd: process.cwd() });
+
+	const unsubscribe = session.subscribe((snapshot) => {
+		console.log(`snapshot revision=${snapshot.revision} phase=${snapshot.phase}`);
+	});
+
+	try {
+		await session.prompt("What files are in the current directory?");
+	} finally {
+		unsubscribe();
+	}
+
+	await session.dispose();
+} finally {
+	await client.dispose();
+	await server.close();
+}