npm - @aprovan/mcp-app-server - Versions diffs - 0.1.0-dev.4d82df8 - Mend

@aprovan/mcp-app-server 0.1.0-dev.4d82df8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (53) hide show

package/.turbo/turbo-build.log +23 -0
package/E2E_TESTING.md +224 -0
package/LICENSE +373 -0
package/README.md +164 -0
package/dist/index.d.ts +128 -0
package/dist/index.js +990 -0
package/dist/index.js.map +1 -0
package/dist/runtime/assets/__vite-browser-external-BIHI7g3E.js +1 -0
package/dist/runtime/assets/index-tRNuU9ap.js +1059 -0
package/dist/runtime/index.html +38 -0
package/dist/server.d.ts +6 -0
package/dist/server.js +1511 -0
package/dist/server.js.map +1 -0
package/dist/shell/shell.js +67 -0
package/docs/widget-preview.png +0 -0
package/e2e/__snapshots__/.gitkeep +0 -0
package/e2e/global-setup.ts +114 -0
package/e2e/global-teardown.ts +15 -0
package/e2e/visual-regression.test.ts +86 -0
package/e2e/widget-smoke.test.ts +109 -0
package/index.html +32 -0
package/package.json +51 -0
package/playwright.config.ts +43 -0
package/src/__tests__/live-update.test.ts +158 -0
package/src/__tests__/local-backend.test.ts +100 -0
package/src/__tests__/memory-backend.ts +144 -0
package/src/__tests__/registry-backend.test.ts +256 -0
package/src/__tests__/services.test.ts +153 -0
package/src/__tests__/shim.test.ts +60 -0
package/src/__tests__/widget-store.test.ts +188 -0
package/src/e2e-visual.ts +148 -0
package/src/index.ts +608 -0
package/src/live-update.ts +150 -0
package/src/logger.ts +44 -0
package/src/reference-widgets/live-dashboard.ts +162 -0
package/src/registry-backend.ts +306 -0
package/src/runtime/index.html +38 -0
package/src/runtime/main.ts +164 -0
package/src/scripts/export-artifacts.ts +51 -0
package/src/server.ts +398 -0
package/src/services.ts +307 -0
package/src/shell/main.ts +172 -0
package/src/shim.ts +106 -0
package/src/tunnel.ts +123 -0
package/src/widget-store/index.ts +10 -0
package/src/widget-store/local-backend.ts +77 -0
package/src/widget-store/store.ts +242 -0
package/src/widget-store/types.ts +53 -0
package/tsconfig.json +10 -0
package/tsup.config.ts +14 -0
package/vite.runtime.config.ts +28 -0
package/vite.shell.config.ts +30 -0
package/vitest.config.ts +7 -0

package/src/__tests__/local-backend.test.ts ADDED Viewed

@@ -0,0 +1,100 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { LocalFileBackend } from "../widget-store/local-backend.js";
+let testDir: string;
+beforeEach(async () => {
+  testDir = resolve(tmpdir(), `widget-store-test-${randomUUID()}`);
+  await mkdir(testDir, { recursive: true });
+});
+afterEach(async () => {
+  await rm(testDir, { recursive: true, force: true });
+});
+describe("LocalFileBackend", () => {
+  it("writes and reads files", async () => {
+    const backend = new LocalFileBackend(testDir);
+    await backend.writeFile("test.txt", "hello");
+    const content = await backend.readFile("test.txt");
+    expect(content).toBe("hello");
+  });
+  it("creates parent directories on write", async () => {
+    const backend = new LocalFileBackend(testDir);
+    await backend.writeFile("sub/dir/file.txt", "nested");
+    const content = await backend.readFile("sub/dir/file.txt");
+    expect(content).toBe("nested");
+  });
+  it("checks file existence", async () => {
+    const backend = new LocalFileBackend(testDir);
+    expect(await backend.exists("missing.txt")).toBe(false);
+    await backend.writeFile("exists.txt", "yes");
+    expect(await backend.exists("exists.txt")).toBe(true);
+  });
+  it("deletes files", async () => {
+    const backend = new LocalFileBackend(testDir);
+    await backend.writeFile("todelete.txt", "bye");
+    await backend.unlink("todelete.txt");
+    expect(await backend.exists("todelete.txt")).toBe(false);
+  });
+  it("stats files and directories", async () => {
+    const backend = new LocalFileBackend(testDir);
+    await backend.writeFile("file.txt", "content");
+    const fileStat = await backend.stat("file.txt");
+    expect(fileStat.isFile()).toBe(true);
+    expect(fileStat.size).toBe(7);
+    await backend.mkdir("mydir");
+    const dirStat = await backend.stat("mydir");
+    expect(dirStat.isDirectory()).toBe(true);
+  });
+  it("lists directory entries", async () => {
+    const backend = new LocalFileBackend(testDir);
+    await backend.writeFile("a.txt", "a");
+    await backend.writeFile("b.txt", "b");
+    await backend.mkdir("subdir");
+    const entries = await backend.readdir("");
+    const names = entries.map((e) => e.name);
+    expect(names).toContain("a.txt");
+    expect(names).toContain("b.txt");
+    expect(names).toContain("subdir");
+    const subdirEntry = entries.find((e) => e.name === "subdir");
+    expect(subdirEntry!.isDirectory()).toBe(true);
+  });
+  it("removes directories recursively", async () => {
+    const backend = new LocalFileBackend(testDir);
+    await backend.mkdir("sub/nested", { recursive: true });
+    await backend.writeFile("sub/nested/file.txt", "data");
+    await backend.rmdir("sub", { recursive: true });
+    expect(await backend.exists("sub")).toBe(false);
+  });
+  it("survives widget store pattern (save + load)", async () => {
+    const backend = new LocalFileBackend(testDir);
+    await backend.writeFile("widgets/my-widget/abc123/view.html", "<html>test</html>");
+    await backend.writeFile(
+      "widgets/my-widget/abc123/manifest.json",
+      JSON.stringify({ name: "my-widget", version: "1.0", hash: "abc123" }),
+    );
+    const html = await backend.readFile("widgets/my-widget/abc123/view.html");
+    expect(html).toBe("<html>test</html>");
+    const manifest = JSON.parse(await backend.readFile("widgets/my-widget/abc123/manifest.json"));
+    expect(manifest.name).toBe("my-widget");
+  });
+});

package/src/__tests__/memory-backend.ts ADDED Viewed

@@ -0,0 +1,144 @@
+import type { DirEntry, FileStats, FSProvider } from "../widget-store/types.js";
+function createDirEntry(name: string, isDir: boolean): DirEntry {
+  return {
+    name,
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+  };
+}
+function createFileStats(size: number, mtime: Date, isDir: boolean): FileStats {
+  return {
+    size,
+    mtime,
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+  };
+}
+interface FileEntry {
+  content: string;
+  mtime: Date;
+}
+export class MemoryBackend implements FSProvider {
+  private files = new Map<string, FileEntry>();
+  private dirs = new Set<string>([""]);
+  async readFile(path: string): Promise<string> {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    const entry = this.files.get(normalized);
+    if (!entry) throw new Error(`ENOENT: ${path}`);
+    return entry.content;
+  }
+  async writeFile(path: string, content: string): Promise<void> {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    const dir = normalized.split("/").slice(0, -1).join("/");
+    if (dir && !this.dirs.has(dir)) {
+      await this.mkdir(dir, { recursive: true });
+    }
+    this.files.set(normalized, { content, mtime: new Date() });
+  }
+  async unlink(path: string): Promise<void> {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    if (!this.files.delete(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+  }
+  async stat(path: string): Promise<FileStats> {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    const entry = this.files.get(normalized);
+    if (entry) {
+      return createFileStats(entry.content.length, entry.mtime, false);
+    }
+    if (this.dirs.has(normalized)) {
+      return createFileStats(0, new Date(), true);
+    }
+    throw new Error(`ENOENT: ${path}`);
+  }
+  async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    if (this.dirs.has(normalized)) return;
+    const parent = normalized.split("/").slice(0, -1).join("/");
+    if (parent && !this.dirs.has(parent)) {
+      if (options?.recursive) {
+        await this.mkdir(parent, options);
+      } else {
+        throw new Error(`ENOENT: ${parent}`);
+      }
+    }
+    this.dirs.add(normalized);
+  }
+  async readdir(path: string): Promise<DirEntry[]> {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    if (!this.dirs.has(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    const prefix = normalized ? `${normalized}/` : "";
+    const entries = new Map<string, boolean>();
+    for (const filePath of this.files.keys()) {
+      if (filePath.startsWith(prefix)) {
+        const rest = filePath.slice(prefix.length);
+        const name = rest.split("/")[0];
+        if (name) entries.set(name, false);
+      }
+    }
+    for (const dirPath of this.dirs) {
+      if (dirPath.startsWith(prefix) && dirPath !== normalized) {
+        const rest = dirPath.slice(prefix.length);
+        const name = rest.split("/")[0];
+        if (name) entries.set(name, true);
+      }
+    }
+    return Array.from(entries).map(([name, isDir]) =>
+      createDirEntry(name, isDir),
+    );
+  }
+  async rmdir(path: string, options?: { recursive?: boolean }): Promise<void> {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    if (!this.dirs.has(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    const prefix = `${normalized}/`;
+    const hasChildren =
+      [...this.files.keys()].some((p) => p.startsWith(prefix)) ||
+      [...this.dirs].some((d) => d.startsWith(prefix));
+    if (hasChildren && !options?.recursive) {
+      throw new Error(`ENOTEMPTY: ${path}`);
+    }
+    if (options?.recursive) {
+      for (const filePath of [...this.files.keys()]) {
+        if (filePath.startsWith(prefix)) {
+          this.files.delete(filePath);
+        }
+      }
+      for (const dirPath of [...this.dirs]) {
+        if (dirPath.startsWith(prefix)) {
+          this.dirs.delete(dirPath);
+        }
+      }
+    }
+    this.dirs.delete(normalized);
+  }
+  async exists(path: string): Promise<boolean> {
+    const normalized = path.replace(/^\/+|\/+$/g, "");
+    return this.files.has(normalized) || this.dirs.has(normalized);
+  }
+}

package/src/__tests__/registry-backend.test.ts ADDED Viewed

@@ -0,0 +1,256 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { parseRegistryToolName, createRegistryBackend } from "../registry-backend.js";
+import type { Mock } from "vitest";
+// ---------------------------------------------------------------------------
+// Module-level mocks (hoisted by vitest)
+// ---------------------------------------------------------------------------
+// Shared mutable ref so each test can configure callTool behaviour.
+let callToolImpl: Mock = vi.fn();
+vi.mock("@modelcontextprotocol/sdk/client/stdio.js", () => ({
+  StdioClientTransport: vi.fn().mockImplementation(() => ({
+    start: vi.fn().mockResolvedValue(undefined),
+    close: vi.fn().mockResolvedValue(undefined),
+    send: vi.fn().mockResolvedValue(undefined),
+    onmessage: null,
+    onclose: null,
+    onerror: null,
+  })),
+}));
+vi.mock("@modelcontextprotocol/sdk/client/index.js", () => ({
+  Client: vi.fn().mockImplementation(() => ({
+    connect: vi.fn().mockResolvedValue(undefined),
+    callTool: (...args: Parameters<Mock>) => callToolImpl(...args),
+    close: vi.fn().mockResolvedValue(undefined),
+  })),
+}));
+// ---------------------------------------------------------------------------
+// Import under test (after mocks are registered)
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function textContent(text: string) {
+  return { type: "text" as const, text };
+}
+function mockSuccess(text: string) {
+  return Promise.resolve({ isError: false, content: [textContent(text)] });
+}
+function mockError(text: string) {
+  return Promise.resolve({ isError: true, content: [textContent(text)] });
+}
+/**
+ * Build a callTool mock that serves list_tools + tool_info for two providers.
+ */
+function twoToolCallTool() {
+  return vi.fn().mockImplementation(({ name, arguments: args }: { name: string; arguments: Record<string, unknown> }) => {
+    if (name === "list_tools") {
+      return mockSuccess(JSON.stringify(["github__repos_list", "stripe__charges_list"]));
+    }
+    if (name === "tool_info") {
+      const schemas: Record<string, object> = {
+        github__repos_list: {
+          name: "github__repos_list",
+          description: "List GitHub repositories",
+          inputSchema: {
+            type: "object",
+            properties: { per_page: { type: "number" } },
+          },
+        },
+        stripe__charges_list: {
+          name: "stripe__charges_list",
+          description: "List Stripe charges",
+          inputSchema: {
+            type: "object",
+            properties: { limit: { type: "number" } },
+          },
+        },
+      };
+      const schema = schemas[args["tool_name"] as string] ?? { name: args["tool_name"] };
+      return mockSuccess(JSON.stringify(schema));
+    }
+    return mockError("unexpected call");
+  });
+}
+// ---------------------------------------------------------------------------
+// parseRegistryToolName
+// ---------------------------------------------------------------------------
+describe("parseRegistryToolName", () => {
+  it("splits on first double-underscore", () => {
+    expect(parseRegistryToolName("github__repos_list")).toEqual({
+      namespace: "github",
+      procedure: "repos_list",
+    });
+  });
+  it("handles procedure with multiple underscores", () => {
+    expect(parseRegistryToolName("stripe__payment_intents_create")).toEqual({
+      namespace: "stripe",
+      procedure: "payment_intents_create",
+    });
+  });
+  it("handles provider with hyphen (e.g. google-cloud-run)", () => {
+    expect(parseRegistryToolName("google-cloud-run__jobs_list")).toEqual({
+      namespace: "google-cloud-run",
+      procedure: "jobs_list",
+    });
+  });
+  it("returns fallback procedure when no separator present", () => {
+    expect(parseRegistryToolName("unknown")).toEqual({
+      namespace: "unknown",
+      procedure: "call",
+    });
+  });
+  it("handles short names like provider__op", () => {
+    expect(parseRegistryToolName("slack__conversations_info")).toEqual({
+      namespace: "slack",
+      procedure: "conversations_info",
+    });
+  });
+});
+// ---------------------------------------------------------------------------
+// createRegistryBackend
+// ---------------------------------------------------------------------------
+describe("createRegistryBackend", () => {
+  beforeEach(() => {
+    // Reset to a fresh mock before each test so tests are independent.
+    callToolImpl = twoToolCallTool();
+  });
+  it("loads tool infos from the Registry and maps them to ServiceToolInfo", async () => {
+    const backend = await createRegistryBackend({
+      command: "npx",
+      args: ["@utdk/mcp"],
+      providers: "github,stripe",
+    });
+    const tools = backend.getToolInfos();
+    expect(tools).toHaveLength(2);
+    const githubTool = tools.find((t) => t.namespace === "github");
+    expect(githubTool).toBeDefined();
+    expect(githubTool?.procedure).toBe("repos_list");
+    expect(githubTool?.name).toBe("github.repos_list");
+    expect(githubTool?.description).toBe("List GitHub repositories");
+    const stripeTool = tools.find((t) => t.namespace === "stripe");
+    expect(stripeTool).toBeDefined();
+    expect(stripeTool?.procedure).toBe("charges_list");
+    expect(stripeTool?.name).toBe("stripe.charges_list");
+  });
+  it("calls the Registry call_tool meta-tool with the correct tool name and args", async () => {
+    const captured: { name: string; arguments: Record<string, unknown> }[] = [];
+    callToolImpl = vi.fn().mockImplementation(({ name, arguments: args }: { name: string; arguments: Record<string, unknown> }) => {
+      captured.push({ name, arguments: args });
+      if (name === "list_tools") return mockSuccess(JSON.stringify(["github__repos_list"]));
+      if (name === "tool_info") {
+        return mockSuccess(JSON.stringify({ name: "github__repos_list", description: "List repos" }));
+      }
+      if (name === "call_tool") {
+        return mockSuccess(JSON.stringify([{ name: "my-repo" }]));
+      }
+      return mockError("unexpected");
+    });
+    const backend = await createRegistryBackend({
+      command: "npx",
+      args: ["@utdk/mcp"],
+      providers: "github",
+    });
+    const result = await backend.call("github", "repos_list", [{ per_page: 10 }]);
+    // Verify the result is parsed JSON
+    expect(result).toEqual([{ name: "my-repo" }]);
+    // Verify call_tool was invoked with the right tool name and arguments
+    const callToolInvocation = captured.find((c) => c.name === "call_tool");
+    expect(callToolInvocation).toBeDefined();
+    expect(callToolInvocation?.arguments["tool_name"]).toBe("github__repos_list");
+    expect(callToolInvocation?.arguments["arguments"]).toEqual({ per_page: 10 });
+  });
+  it("throws when the Registry returns isError = true", async () => {
+    callToolImpl = vi.fn().mockImplementation(({ name }: { name: string }) => {
+      if (name === "list_tools") return mockSuccess(JSON.stringify([]));
+      if (name === "call_tool") return mockError("Unknown tool: bad__tool");
+      return mockError("unexpected");
+    });
+    const backend = await createRegistryBackend({
+      command: "npx",
+      args: ["@utdk/mcp"],
+      providers: "bad",
+    });
+    await expect(backend.call("bad", "tool", [{}])).rejects.toThrow("Unknown tool: bad__tool");
+  });
+  it("parses JSON response from call_tool automatically", async () => {
+    callToolImpl = vi.fn().mockImplementation(({ name }: { name: string }) => {
+      if (name === "list_tools") return mockSuccess(JSON.stringify([]));
+      if (name === "call_tool") {
+        return mockSuccess(JSON.stringify({ id: "ch_123", amount: 5000 }));
+      }
+      return mockError("unexpected");
+    });
+    const backend = await createRegistryBackend({
+      command: "npx",
+      args: ["@utdk/mcp"],
+      providers: "stripe",
+    });
+    const result = await backend.call("stripe", "charges_retrieve", [{ id: "ch_123" }]);
+    expect(result).toEqual({ id: "ch_123", amount: 5000 });
+  });
+  it("returns plain text when response is not valid JSON", async () => {
+    callToolImpl = vi.fn().mockImplementation(({ name }: { name: string }) => {
+      if (name === "list_tools") return mockSuccess(JSON.stringify([]));
+      if (name === "call_tool") return mockSuccess("plain text response");
+      return mockError("unexpected");
+    });
+    const backend = await createRegistryBackend({
+      command: "npx",
+      args: ["@utdk/mcp"],
+      providers: "some",
+    });
+    const result = await backend.call("some", "op", [{}]);
+    expect(result).toBe("plain text response");
+  });
+  it("handles an empty tool list gracefully", async () => {
+    callToolImpl = vi.fn().mockImplementation(({ name }: { name: string }) => {
+      if (name === "list_tools") return mockSuccess(JSON.stringify([]));
+      return mockError("should not be called");
+    });
+    const backend = await createRegistryBackend({
+      command: "npx",
+      args: ["@utdk/mcp"],
+      providers: "",
+    });
+    expect(backend.getToolInfos()).toHaveLength(0);
+  });
+});

package/src/__tests__/services.test.ts ADDED Viewed

@@ -0,0 +1,153 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { describe, it, expect, vi } from "vitest";
+import { ServiceBridge, type ServiceBackend, type ServiceToolInfo } from "../services.js";
+const mockBackend: ServiceBackend = {
+  call: vi.fn(async () => ({
+    result: "mock-data",
+  })),
+};
+const mockTools: ServiceToolInfo[] = [
+  {
+    name: "weather.get_forecast",
+    namespace: "weather",
+    procedure: "get_forecast",
+    description: "Get weather forecast for a location",
+    parameters: {
+      type: "object",
+      properties: {
+        latitude: { type: "number", description: "Latitude" },
+        longitude: { type: "number", description: "Longitude" },
+      },
+      required: ["latitude", "longitude"],
+    },
+  },
+  {
+    name: "weather.get_current_conditions",
+    namespace: "weather",
+    procedure: "get_current_conditions",
+    description: "Get current weather conditions",
+    parameters: {
+      type: "object",
+      properties: {
+        location: { type: "string", description: "Location name" },
+      },
+    },
+  },
+  {
+    name: "stripe.create_payment",
+    namespace: "stripe",
+    procedure: "create_payment",
+    description: "Create a payment intent",
+    parameters: {
+      type: "object",
+      properties: {
+        amount: { type: "number", description: "Amount in cents" },
+        currency: { type: "string", description: "Currency code" },
+      },
+      required: ["amount"],
+    },
+  },
+];
+describe("ServiceBridge", () => {
+  describe("constructor", () => {
+    it("stores tools from config", () => {
+      const bridge = new ServiceBridge({
+        backend: mockBackend,
+        tools: mockTools,
+      });
+      expect(bridge.getToolInfos()).toHaveLength(3);
+      expect(bridge.getNamespaces()).toEqual(["weather", "stripe"]);
+    });
+    it("handles empty tools array", () => {
+      const bridge = new ServiceBridge({
+        backend: mockBackend,
+        tools: [],
+      });
+      expect(bridge.getToolInfos()).toHaveLength(0);
+      expect(bridge.getNamespaces()).toEqual([]);
+    });
+  });
+  describe("getNamespaces", () => {
+    it("returns unique namespaces", () => {
+      const bridge = new ServiceBridge({
+        backend: mockBackend,
+        tools: mockTools,
+      });
+      const namespaces = bridge.getNamespaces();
+      expect(namespaces).toContain("weather");
+      expect(namespaces).toContain("stripe");
+      expect(namespaces).toHaveLength(2);
+    });
+  });
+  describe("has", () => {
+    it("returns true for existing tools", () => {
+      const bridge = new ServiceBridge({
+        backend: mockBackend,
+        tools: mockTools,
+      });
+      expect(bridge.has("weather", "get_forecast")).toBe(true);
+      expect(bridge.has("stripe", "create_payment")).toBe(true);
+    });
+    it("returns false for missing tools", () => {
+      const bridge = new ServiceBridge({
+        backend: mockBackend,
+        tools: mockTools,
+      });
+      expect(bridge.has("weather", "nonexistent")).toBe(false);
+      expect(bridge.has("unknown", "something")).toBe(false);
+    });
+  });
+  describe("registerTools", () => {
+    it("registers service tools on the MCP server", () => {
+      const bridge = new ServiceBridge({
+        backend: mockBackend,
+        tools: mockTools,
+      });
+      const server = new McpServer({
+        name: "test-server",
+        version: "0.1.0",
+      });
+      bridge.registerTools(server);
+    });
+  });
+  describe("registerSearchServices", () => {
+    it("registers search_services tool on the MCP server", () => {
+      const bridge = new ServiceBridge({
+        backend: mockBackend,
+        tools: mockTools,
+      });
+      const server = new McpServer({
+        name: "test-server",
+        version: "0.1.0",
+      });
+      bridge.registerSearchServices(server);
+    });
+  });
+  describe("tool name mapping", () => {
+    it("uses __ separator for MCP tool names (not dots)", () => {
+      const bridge = new ServiceBridge({
+        backend: mockBackend,
+        tools: mockTools,
+      });
+      // The internal tool names use dots, but MCP tool names use __
+      // We can verify this by checking the tool infos still have dot names
+      const toolInfo = bridge.getToolInfos();
+      expect(toolInfo[0]?.name).toBe("weather.get_forecast");
+      expect(toolInfo[0]?.namespace).toBe("weather");
+      expect(toolInfo[0]?.procedure).toBe("get_forecast");
+    });
+  });
+});