@ryuhq/sdk 0.1.14 → 0.2.2

package/src/agent/loop.test.ts

@@ -163,7 +163,7 @@ describe("runAgentLoop", () => {
 			agentId: "agent-expense",
 			userId: "user-1",
 			tools: {
-				gmailSearch: ryuTool("composio__GMAIL_SEARCH_EMAILS", {
+				gmailSearch: ryuTool("composio.GMAIL_SEARCH_EMAILS", {
 					description: "Search Gmail",
 					parameters: {
 						type: "object",
@@ -176,7 +176,7 @@ describe("runAgentLoop", () => {
 
 		const events = await collect(agent.stream("find expenses"));
 		expect(captured.body).not.toBeNull();
-		expect(captured.body?.tool).toBe("composio__GMAIL_SEARCH_EMAILS");
+		expect(captured.body?.tool).toBe("composio.GMAIL_SEARCH_EMAILS");
 		expect(captured.body?.agent_id).toBe("agent-expense");
 		expect(captured.body?.user_id).toBe("user-1");
 		const result = events.find((e) => e.type === "result");
@@ -208,7 +208,7 @@ describe("runAgentLoop", () => {
 			node: { baseUrl: NODE },
 			agentId: "agent-expense",
 			tools: {
-				gmailSearch: ryuTool("composio__GMAIL_SEARCH_EMAILS", {
+				gmailSearch: ryuTool("composio.GMAIL_SEARCH_EMAILS", {
 					parameters: { type: "object", properties: {} },
 				}),
 			},
@@ -242,7 +242,7 @@ describe("runAgentLoop", () => {
 describe("executeTool", () => {
 	it("throws when a remote tool is used without an agentId", async () => {
 		const tools = {
-			gmailSearch: ryuTool("composio__GMAIL_SEARCH_EMAILS"),
+			gmailSearch: ryuTool("composio.GMAIL_SEARCH_EMAILS"),
 		};
 		await expect(
 			executeTool("gmailSearch", "{}", tools, {

package/src/agent/tools.ts

@@ -6,7 +6,7 @@
  *  - **Local** tools are `ToolRunnable`s from `defineTool` — they run in-process
  *    via their `run(input, ctx)` implementation.
  *  - **Remote** tools are references to existing Ryu tools (e.g.
- *    `composio__GMAIL_SEARCH_EMAILS`) created with `ryuTool(id)`. Their schema is
+ *    `composio.GMAIL_SEARCH_EMAILS`) created with `ryuTool(id)`. Their schema is
  *    lazily fetched from Core `GET /api/tools/describe` and they execute through
  *    Core `POST /api/mcp/tools/call`, which enforces the agent's allowlist and
  *    selects the Composio connected-account entity via `user_id`.
@@ -26,7 +26,7 @@ import type { ToolFunctionDef } from "./model-call.ts";
 export interface RemoteToolRef {
 	/** One-line description shown to the model (overrides Core's describe). */
 	description?: string;
-	/** Fully-qualified Ryu tool id, e.g. `composio__GMAIL_SEARCH_EMAILS`. */
+	/** Fully-qualified Ryu tool id, e.g. `composio.GMAIL_SEARCH_EMAILS`. */
 	id: string;
 	readonly kind: "remote";
 	/**
@@ -48,7 +48,7 @@ export interface RyuToolOptions {
  *
  * @example
  * ```ts
- * ryuTool("composio__GMAIL_SEARCH_EMAILS", {
+ * ryuTool("composio.GMAIL_SEARCH_EMAILS", {
  *   description: "Search the user's Gmail",
  *   parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
  * });

package/src/agent-plugin.test.ts

@@ -183,6 +183,64 @@ describe("toAgentPlugin", () => {
 		});
 	});
 
+	test("exports Streamable HTTP, legacy SSE, and inferred remote servers", () => {
+		const { mcp, notes } = toAgentPlugin({
+			id: "@ryu/remote",
+			name: "Remote",
+			mcp_servers: {
+				hosted: {
+					type: "streamable-http",
+					url: "https://mcp.example.com/mcp",
+					headers: { Authorization: "Bearer static" },
+				},
+				legacy: {
+					type: "sse",
+					url: "https://legacy.example.com/sse",
+				},
+				inferred: { url: "https://inferred.example.com/mcp" },
+			},
+		});
+		expect(mcp?.mcpServers.hosted).toEqual({
+			type: "streamable-http",
+			url: "https://mcp.example.com/mcp",
+			headers: { Authorization: "Bearer static" },
+		});
+		expect(mcp?.mcpServers.legacy).toEqual({
+			type: "sse",
+			url: "https://legacy.example.com/sse",
+		});
+		expect(mcp?.mcpServers.inferred).toEqual({
+			type: "streamable-http",
+			url: "https://inferred.example.com/mcp",
+		});
+		expect(notes).toEqual([]);
+	});
+
+	test("omits malformed remote URLs while preserving valid HTTP endpoints", () => {
+		const { mcp, notes } = toAgentPlugin({
+			id: "@ryu/remote",
+			name: "Remote",
+			mcp_servers: {
+				insecure: {
+					type: "streamable-http",
+					url: "http://remote.example.com/mcp",
+				},
+				bad: { type: "streamable-http", url: "file:///tmp/mcp" },
+				local: { type: "sse", url: "http://127.0.0.1:8787/sse" },
+			},
+		});
+		expect(mcp?.mcpServers.insecure).toEqual({
+			type: "streamable-http",
+			url: "http://remote.example.com/mcp",
+		});
+		expect(mcp?.mcpServers.local).toEqual({
+			type: "sse",
+			url: "http://127.0.0.1:8787/sse",
+		});
+		expect(notes).toHaveLength(1);
+		expect(notes[0]).toContain("http or https");
+	});
+
 	test("omits a disabled server but records it", () => {
 		const { plugin, mcp, notes } = toAgentPlugin({
 			id: "@ryu/a",

package/src/agent-plugin.ts

@@ -4,7 +4,9 @@
  * The Agent Plugins Specification (https://agent-plugins.org/, TSC: Amazon,
  * Cursor, Microsoft, OpenAI, Vercel) defines a small portable floor: a plugin is
  * a directory with `plugin.json`, Agent Skills under `skills/<slug>/SKILL.md`,
- * and MCP servers in `mcp.json`. Nothing else is portable.
+ * and MCP servers in `mcp.json`. Native stdio, Streamable HTTP, and legacy SSE
+ * servers all have a direct portable representation; richer Ryu-only fields stay
+ * in the extension namespace or are reported as notes.
  *
  * ## Why this is a SECOND file, not a migration
  *
@@ -27,7 +29,7 @@
  * is deliberately NOT a copy of the whole native manifest — that would be a second
  * source of truth with a stale-copy failure mode.
  *
- * Both `plugins-store/*` and `apps-store/*` use this one `PluginManifest` shape, so
+ * Both `plugins-store/{plugins,lsp,external_plugins}/*` and `apps-store/*` use this one `PluginManifest` shape, so
  * one converter covers both stores.
  */
 
@@ -88,24 +90,24 @@ export function isAgentPluginManifest(value: unknown): boolean {
 }
 
 /** Author object — the only three fields the spec permits (§5.4). */
-export type AgentPluginAuthor = {
-	name?: string;
+export interface AgentPluginAuthor {
 	email?: string;
+	name?: string;
 	url?: string;
-};
+}
 
 /** Ryu data carried under {@link AGENT_PLUGIN_EXTENSION_NS}. */
-export type RyuExtensionData = {
-	/** The real scoped plugin id (`@ryu/advisor`) — unrecoverable from spec `name`. */
-	id: string;
+export interface RyuExtensionData {
 	/** Human display name; spec `name` is a slug, not a display string. */
 	displayName: string;
+	/** The real scoped plugin id (`@ryu/advisor`) — unrecoverable from spec `name`. */
+	id: string;
 	/** Per-MCP-server fields the spec's closed server variants do not allow. */
 	mcp?: Record<string, RyuMcpServerExtras>;
-};
+}
 
 /** Native MCP fields stripped out of the exported `mcp.json`. */
-export type RyuMcpServerExtras = {
+export interface RyuMcpServerExtras {
 	/** Env var that overrides `command` with an absolute path at spawn. */
 	command_env?: string;
 	/** Human description for our MCP listing endpoint. */
@@ -117,41 +119,51 @@ export type RyuMcpServerExtras = {
 	 * deliberately do not.
 	 */
 	enabled?: false;
-};
+}
 
 /** A conformant `plugin.json` (§5.2). */
-export type AgentPluginJson = {
+export interface AgentPluginJson {
 	$schema: string;
-	name: string;
-	version?: string;
-	description?: string;
 	author?: AgentPluginAuthor;
+	description?: string;
+	extensions: Record<string, unknown>;
 	homepage?: string;
-	repository?: string;
-	license?: string;
 	keywords?: string[];
-	extensions: Record<string, unknown>;
-};
+	license?: string;
+	name: string;
+	repository?: string;
+	version?: string;
+}
 
-/** A stdio server entry (§7.2.1) — the only variant we export. */
-export type AgentPluginStdioServer = {
-	type: "stdio";
-	command: string;
+/** A stdio server entry (§7.2.1). */
+export interface AgentPluginStdioServer {
 	args?: string[];
-	env?: Record<string, string>;
+	command: string;
 	cwd?: string;
-};
+	env?: Record<string, string>;
+	type: "stdio";
+}
+
+/** A remote server entry (§7.2.1). */
+export interface AgentPluginRemoteServer {
+	headers?: Record<string, string>;
+	type: "streamable-http" | "sse";
+	url: string;
+}
+
+/** Any server variant a conformant Agent Plugins client can consume. */
+export type AgentPluginServer =
+	| AgentPluginStdioServer
+	| AgentPluginRemoteServer;
 
 /** A conformant `mcp.json` (§7.2.1). */
-export type AgentPluginMcpJson = {
+export interface AgentPluginMcpJson {
 	$schema: string;
-	mcpServers: Record<string, AgentPluginStdioServer>;
-};
+	mcpServers: Record<string, AgentPluginServer>;
+}
 
 /** What {@link toAgentPlugin} produces, plus what it had to leave behind. */
-export type AgentPluginExport = {
-	/** The `plugin.json` contents. */
-	plugin: AgentPluginJson;
+export interface AgentPluginExport {
 	/** The `mcp.json` contents, or null when the plugin exports no server. */
 	mcp: AgentPluginMcpJson | null;
 	/**
@@ -159,7 +171,9 @@ export type AgentPluginExport = {
 	 * is visible at the call site instead of silent.
 	 */
 	notes: string[];
-};
+	/** The `plugin.json` contents. */
+	plugin: AgentPluginJson;
+}
 
 const SPEC_NAME_MAX = 64;
 const ILLEGAL_NAME_CHARS = /[^a-z0-9.-]+/g;
@@ -258,8 +272,24 @@ function toSpecEnv(value: unknown): Record<string, string> | undefined {
 	return Object.keys(env).length > 0 ? env : undefined;
 }
 
+function validateRemoteUrl(name: string, raw: string): string | undefined {
+	let parsed: URL;
+	try {
+		parsed = new URL(raw);
+	} catch {
+		return `mcp server '${name}' remote url ${JSON.stringify(raw)} is invalid and was omitted`;
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+		return `mcp server '${name}' remote url must use http or https and was omitted`;
+	}
+	if (parsed.username || parsed.password || parsed.hash) {
+		return `mcp server '${name}' remote url must not contain credentials or a fragment and was omitted`;
+	}
+	return undefined;
+}
+
 /**
- * Convert one native MCP server declaration to a spec stdio entry, or return the
+ * Convert one native MCP server declaration to a spec entry, or return the
  * reason it cannot be exported.
  *
  * Strictness is not optional here and differs from the manifest: an unknown field
@@ -270,7 +300,7 @@ function toSpecEnv(value: unknown): Record<string, string> | undefined {
 function toSpecServer(
 	name: string,
 	decl: Record<string, unknown>
-): { server?: AgentPluginStdioServer; extras: RyuMcpServerExtras; note?: string } {
+): { server?: AgentPluginServer; extras: RyuMcpServerExtras; note?: string } {
 	const extras: RyuMcpServerExtras = {};
 	const commandEnv = asString(decl.command_env);
 	const description = asString(decl.description);
@@ -289,6 +319,48 @@ function toSpecServer(
 		};
 	}
 
+	const declaredType = asString(decl.type);
+	const remoteUrl = asString(decl.url);
+	const remoteType =
+		declaredType === "sse"
+			? "sse"
+			: declaredType === "streamable-http" ||
+					declaredType === "streamable_http" ||
+					declaredType === "http" ||
+					(!declaredType && remoteUrl)
+				? "streamable-http"
+				: undefined;
+	if (remoteType) {
+		if (!remoteUrl) {
+			return {
+				extras,
+				note: `mcp server '${name}' has remote type '${remoteType}' but no url and was omitted`,
+			};
+		}
+		const urlNote = validateRemoteUrl(name, remoteUrl);
+		if (urlNote) {
+			return { extras, note: urlNote };
+		}
+		const server: AgentPluginRemoteServer = {
+			type: remoteType,
+			url: remoteUrl,
+		};
+		const headers = toSpecEnv(decl.headers);
+		if (headers) {
+			server.headers = headers;
+		}
+		const note = decl.auth
+			? `mcp server '${name}' uses Ryu OAuth metadata that is not portable; static headers were exported`
+			: undefined;
+		return { server, extras, note };
+	}
+	if (declaredType && declaredType !== "stdio") {
+		return {
+			extras,
+			note: `mcp server '${name}' has unsupported transport '${declaredType}' and was omitted`,
+		};
+	}
+
 	const command = asString(decl.command);
 	if (!command) {
 		return {
@@ -359,7 +431,8 @@ export function toAgentPlugin(
 	}
 	// `tagline` is our one-line pitch; it is the better `description` when no long
 	// description exists, and the spec has no second summary field to put it in.
-	const description = asString(manifest.description) ?? asString(manifest.tagline);
+	const description =
+		asString(manifest.description) ?? asString(manifest.tagline);
 	if (description) {
 		plugin.description = description;
 	}
@@ -385,7 +458,7 @@ export function toAgentPlugin(
 	}
 
 	const declared = manifest.mcp_servers;
-	const servers: Record<string, AgentPluginStdioServer> = {};
+	const servers: Record<string, AgentPluginServer> = {};
 	const mcpExtras: Record<string, RyuMcpServerExtras> = {};
 	if (declared && typeof declared === "object" && !Array.isArray(declared)) {
 		for (const [name, raw] of Object.entries(

package/src/builder.ts

@@ -16,6 +16,7 @@ import type {
 	CompanionSurface,
 	PluginManifest,
 	RunnableMeta,
+	SlashCommandContribution,
 	Surface,
 } from "./manifest.ts";
 import { PluginManifestSchema, RunnableMetaSchema } from "./manifest.ts";
@@ -325,6 +326,7 @@ export class AppBuilder {
 	private readonly _dependencies: AppDependency[] = [];
 	private readonly _requiredCapabilities: CapabilityReq[] = [];
 	private readonly _requiredGrants: string[] = [];
+	private readonly _slashCommands: SlashCommandContribution[] = [];
 	private readonly _targets: Surface[] = [];
 
 	/** Set the reverse-domain app id (e.g. `"com.example.checklist"`). */
@@ -393,6 +395,12 @@ export class AppBuilder {
 		return this;
 	}
 
+	/** Add a slash command and its optional sequential argument choices. */
+	slashCommand(command: SlashCommandContribution): this {
+		this._slashCommands.push(command);
+		return this;
+	}
+
 	/**
 	 * Declare a **plugin-to-plugin dependency** (auto-enabled, in dependency order,
 	 * before this app). `minVersion` is a MINIMUM (`"1.2.0"` = `">=1.2.0"`).
@@ -448,6 +456,7 @@ export class AppBuilder {
 			uiEntry: this._uiEntry,
 			tools: this._tools,
 			grants: this._grants,
+			slashCommands: this._slashCommands,
 			...(this._server ? { server: this._server } : {}),
 			...(this._displayMode ? { displayMode: this._displayMode } : {}),
 			...(this._mime ? { mime: this._mime } : {}),

package/src/cli/dev.test.ts

@@ -3,57 +3,27 @@
  * sample Runnable, asserting that text, tool-call, and tool-result events
  * stream to stdout correctly.
  *
- * The mock gateway is an in-process HTTP server (Bun.serve) that returns a
- * pre-canned SSE response so the test never needs a real gateway running.
+ * The mock gateway is an in-process request handler so the test never needs a
+ * real gateway or a listening socket.
  */
 
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { describe, expect, it } from "bun:test";
 import { unlinkSync, writeFileSync } from "node:fs";
-import { serve } from "bun";
-import type { ChatMessage } from "../model/client.ts";
-import { ModelClient } from "../model/client.ts";
-import type { DevEvent, Runnable } from "./dev.ts";
+import type { ChatMessage, ModelClient } from "../model/client.ts";
+import type { DevEvent, GatewayFetch, Runnable } from "./dev.ts";
 import { loadRunnable, probeGateway, runTurn } from "./dev.ts";
 
 // ── Mock gateway ──────────────────────────────────────────────────────────────
 
-/** Pre-canned SSE body the mock gateway returns for any chat completions POST. */
-const MOCK_SSE_BODY = [
-	'data: {"choices":[{"delta":{"content":"Hello"},"finish_reason":null}]}',
-	'data: {"choices":[{"delta":{"content":", world"},"finish_reason":null}]}',
-	'data: {"choices":[{"delta":{"content":"!"},"finish_reason":"stop"}]}',
-	"data: [DONE]",
-].join("\n");
-
-let mockServer: ReturnType<typeof serve>;
-let mockBaseUrl: string;
-
-beforeAll(() => {
-	mockServer = serve({
-		port: 0, // OS-assigned port
-		fetch(req) {
-			const url = new URL(req.url);
-
-			if (url.pathname === "/health") {
-				return new Response("ok", { status: 200 });
-			}
-
-			if (url.pathname === "/v1/chat/completions") {
-				return new Response(MOCK_SSE_BODY, {
-					status: 200,
-					headers: { "Content-Type": "text/event-stream" },
-				});
-			}
-
-			return new Response("not found", { status: 404 });
-		},
-	});
-	mockBaseUrl = `http://127.0.0.1:${mockServer.port}`;
-});
-
-afterAll(() => {
-	mockServer.stop();
-});
+/** Stable gateway URL used by the injected health request handler. */
+const MOCK_GATEWAY_URL = "http://mock-gateway.test";
+const mockFetch: GatewayFetch = async (input) => {
+	const url = new URL(String(input));
+	if (url.pathname === "/health") {
+		return new Response("ok", { status: 200 });
+	}
+	return new Response("not found", { status: 404 });
+};
 
 // ── Sample Runnable ───────────────────────────────────────────────────────────
 
@@ -98,7 +68,7 @@ const sampleRunnable: Runnable = {
 
 describe("probeGateway", () => {
 	it("returns true when the gateway /health responds", async () => {
-		const reachable = await probeGateway(mockBaseUrl);
+		const reachable = await probeGateway(MOCK_GATEWAY_URL, mockFetch);
 		expect(reachable).toBe(true);
 	});
 
@@ -130,7 +100,16 @@ describe("loadRunnable", () => {
 
 describe("runTurn — full turn streams to stdout", () => {
 	it("collects text + tool events from a full turn", async () => {
-		const model = new ModelClient("test-model", { baseUrl: mockBaseUrl });
+		const model = {
+			async *stream(): AsyncGenerator<{
+				content: string;
+				finishReason: string | null;
+			}> {
+				for (const content of ["Hello", ", world", "!"]) {
+					yield { content, finishReason: null };
+				}
+			},
+		} as unknown as ModelClient;
 
 		const events: DevEvent[] = [];
 
@@ -158,7 +137,7 @@ describe("runTurn — full turn streams to stdout", () => {
 		const toolCallEvents = events.filter((e) => e.type === "tool_call");
 		const toolResultEvents = events.filter((e) => e.type === "tool_result");
 
-		// Three text chunks from the mock SSE body.
+		// Three text chunks from the mock model stream.
 		expect(textEvents).toHaveLength(3);
 		const fullText = textEvents
 			.map((e) => (e as { content: string }).content)

package/src/cli/dev.ts

@@ -93,15 +93,23 @@ export interface Runnable {
 
 // ── Gateway reachability check ────────────────────────────────────────────────
 
+export type GatewayFetch = (
+	input: string | URL | Request,
+	init?: RequestInit
+) => Promise<Response>;
+
 /**
  * Probe the gateway at `baseUrl` with a HEAD request.
  *
  * Returns `true` when any HTTP response is received (even 4xx — the gateway
  * is reachable), `false` when the request fails with a network error.
  */
-export async function probeGateway(baseUrl: string): Promise<boolean> {
+export async function probeGateway(
+	baseUrl: string,
+	fetchImpl: GatewayFetch = fetch
+): Promise<boolean> {
 	try {
-		await fetch(`${baseUrl}/health`, {
+		await fetchImpl(`${baseUrl}/health`, {
 			method: "HEAD",
 			signal: AbortSignal.timeout(3000),
 		});

package/src/cli-security.test.ts

@@ -0,0 +1,109 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { spawnSync } from "node:child_process";
+import {
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	symlinkSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+const REPO_ROOT = join(import.meta.dir, "../../..");
+const CLI = join(import.meta.dir, "cli.ts");
+const temporaryDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of temporaryDirectories.splice(0)) {
+		rmSync(directory, { force: true, recursive: true });
+	}
+});
+
+function temporaryPackage(): string {
+	const directory = mkdtempSync(join(tmpdir(), "ryu-sdk-pack-"));
+	temporaryDirectories.push(directory);
+	return directory;
+}
+
+function runPack(directory: string) {
+	return spawnSync(process.execPath, [CLI, "pack", directory], {
+		encoding: "utf8",
+	});
+}
+
+describe.skipIf(process.platform === "win32")(
+	"ryu pack package containment",
+	() => {
+		it("rejects external symlinks for hooks, adapters, and output styles", () => {
+			const scenarios = [
+				{
+					manifest: "plugins-store/plugins/tool-firewall/manifest.json",
+					linkedFile: "hooks/pre.js",
+					copiedFiles: ["hooks/post.js"],
+				},
+				{
+					manifest:
+						"plugins-store/external_plugins/cloudflare-browser-run/manifest.json",
+					linkedFile: "adapters/browser.navigate.js",
+					copiedFiles: [
+						"adapters/browser.screenshot.js",
+						"adapters/browser.snapshot.js",
+					],
+				},
+				{
+					manifest: "plugins-store/plugins/output-styles/manifest.json",
+					linkedFile: "output-styles/i-have-adhd.md",
+					copiedFiles: [
+						"output-styles/bro.md",
+						"output-styles/eli5.md",
+						"output-styles/explanatory.md",
+						"output-styles/gen-z.md",
+						"output-styles/learning.md",
+						"output-styles/no-ai-slop.md",
+						"output-styles/no-hype.md",
+						"output-styles/plain-technical.md",
+						"output-styles/plain-text.md",
+						"output-styles/proactive.md",
+					],
+				},
+			];
+
+			for (const scenario of scenarios) {
+				const directory = temporaryPackage();
+				const sourceRoot = dirname(join(REPO_ROOT, scenario.manifest));
+				writeFileSync(
+					join(directory, "manifest.json"),
+					readFileSync(join(REPO_ROOT, scenario.manifest))
+				);
+				for (const file of scenario.copiedFiles) {
+					mkdirSync(dirname(join(directory, file)), { recursive: true });
+					writeFileSync(
+						join(directory, file),
+						readFileSync(join(sourceRoot, file))
+					);
+				}
+				mkdirSync(dirname(join(directory, scenario.linkedFile)), {
+					recursive: true,
+				});
+				writeFileSync(
+					join(directory, scenario.linkedFile),
+					readFileSync(join(sourceRoot, scenario.linkedFile))
+				);
+				const workingResult = runPack(directory);
+				expect(workingResult.status).toBe(0);
+				unlinkSync(join(directory, scenario.linkedFile));
+
+				const external = join(dirname(directory), `${Date.now()}-outside.txt`);
+				writeFileSync(external, "private host data");
+				symlinkSync(external, join(directory, scenario.linkedFile));
+
+				const result = runPack(directory);
+				expect(result.status).toBe(1);
+				rmSync(external, { force: true });
+			}
+		});
+	}
+);