@line-harness/mcp-server 0.2.2 → 0.4.1

package/src/tools/create-rich-menu.ts

@@ -0,0 +1,90 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getClient } from "../client.js";
+
+export function registerCreateRichMenu(server: McpServer): void {
+  server.tool(
+    "create_rich_menu",
+    "Create a LINE rich menu (the persistent menu at the bottom of the chat). Image must be uploaded separately via LINE Developers Console. This creates the menu structure and button areas.",
+    {
+      name: z.string().describe("Rich menu name"),
+      chatBarText: z
+        .string()
+        .default("\u30E1\u30CB\u30E5\u30FC")
+        .describe("Text shown on the chat bar button"),
+      size: z
+        .object({
+          width: z
+            .number()
+            .default(2500)
+            .describe("Menu width in pixels (2500 for full-width)"),
+          height: z
+            .number()
+            .default(1686)
+            .describe("Menu height: 1686 for full, 843 for half"),
+        })
+        .default({ width: 2500, height: 1686 })
+        .describe("Menu size in pixels"),
+      selected: z
+        .boolean()
+        .default(false)
+        .describe("Whether the rich menu is displayed by default"),
+      areas: z
+        .string()
+        .describe(
+          "JSON string of menu button areas. Format: [{ bounds: { x, y, width, height }, action: { type: 'uri'|'message'|'postback', uri?, text?, data? } }]",
+        ),
+      setAsDefault: z
+        .boolean()
+        .default(false)
+        .describe("Set this as the default rich menu for all friends"),
+    },
+    async ({ name, chatBarText, size, selected, areas, setAsDefault }) => {
+      try {
+        const client = getClient();
+        const menu = await client.richMenus.create({
+          name,
+          chatBarText,
+          size,
+          selected,
+          areas: JSON.parse(areas),
+        });
+
+        if (setAsDefault) {
+          await client.richMenus.setDefault(menu.richMenuId);
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                {
+                  success: true,
+                  richMenuId: menu.richMenuId,
+                  isDefault: setAsDefault,
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: false, error: String(error) },
+                null,
+                2,
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/src/tools/create-scenario.ts

@@ -0,0 +1,152 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { parseDelay } from "@line-harness/sdk";
+import { getClient } from "../client.js";
+
+export function registerCreateScenario(server: McpServer): void {
+  server.tool(
+    "create_scenario",
+    "Create a step delivery scenario with multiple message steps. Each step has a delay and message content. Scenarios auto-trigger on friend_add, tag_added, or manual enrollment.",
+    {
+      name: z.string().describe("Scenario name"),
+      triggerType: z
+        .enum(["friend_add", "tag_added", "manual"])
+        .describe(
+          "When to start: 'friend_add' on new friends, 'tag_added' when a tag is applied, 'manual' for explicit enrollment",
+        ),
+      triggerTagId: z
+        .string()
+        .optional()
+        .describe(
+          "Required when triggerType is 'tag_added': the tag ID that triggers this scenario",
+        ),
+      steps: z
+        .array(
+          z.object({
+            delay: z
+              .string()
+              .describe(
+                "Delay before sending. Format: '0m' for immediate, '30m' for 30 minutes, '24h' for 24 hours",
+              ),
+            type: z.enum(["text", "flex"]).describe("Message type"),
+            content: z.string().describe("Message content"),
+          }),
+        )
+        .describe("Ordered list of message steps"),
+      accountId: z
+        .string()
+        .optional()
+        .describe("LINE account ID (uses default if omitted)"),
+    },
+    async ({ name, triggerType, triggerTagId, steps, accountId }) => {
+      try {
+        if (triggerType === "tag_added" && !triggerTagId) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify(
+                  {
+                    success: false,
+                    error:
+                      "triggerTagId is required when triggerType is 'tag_added'",
+                  },
+                  null,
+                  2,
+                ),
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        const parsedSteps: Array<{
+          delayMinutes: number;
+          type: "text" | "flex";
+          content: string;
+        }> = [];
+
+        for (let i = 0; i < steps.length; i++) {
+          const step = steps[i];
+          let delayMinutes: number;
+          try {
+            delayMinutes = parseDelay(step.delay);
+          } catch {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: JSON.stringify(
+                    {
+                      success: false,
+                      error: `Invalid delay format at step ${i + 1}: "${step.delay}". Use formats like '0m', '30m', '24h'.`,
+                    },
+                    null,
+                    2,
+                  ),
+                },
+              ],
+              isError: true,
+            };
+          }
+          parsedSteps.push({
+            delayMinutes,
+            type: step.type,
+            content: step.content,
+          });
+        }
+
+        const client = getClient();
+        const scenario = await client.scenarios.create({
+          name,
+          triggerType,
+          triggerTagId,
+          lineAccountId: accountId,
+        });
+
+        try {
+          for (let i = 0; i < parsedSteps.length; i++) {
+            const step = parsedSteps[i];
+            await client.scenarios.addStep(scenario.id, {
+              stepOrder: i + 1,
+              delayMinutes: step.delayMinutes,
+              messageType: step.type,
+              messageContent: step.content,
+            });
+          }
+        } catch (stepError) {
+          await client.scenarios.delete(scenario.id).catch(() => {});
+          throw stepError;
+        }
+
+        const scenarioWithSteps = await client.scenarios.get(scenario.id);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: true, scenario: scenarioWithSteps },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: false, error: String(error) },
+                null,
+                2,
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/src/tools/create-tracked-link.ts

@@ -0,0 +1,57 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getClient } from "../client.js";
+
+export function registerCreateTrackedLink(server: McpServer): void {
+  server.tool(
+    "create_tracked_link",
+    "Create a click-tracking link. When clicked, can auto-tag the user and enroll them in a scenario.",
+    {
+      name: z.string().describe("Link name (internal label)"),
+      originalUrl: z
+        .string()
+        .describe("The destination URL to redirect to"),
+      tagId: z
+        .string()
+        .optional()
+        .describe("Tag ID to auto-apply on click"),
+      scenarioId: z
+        .string()
+        .optional()
+        .describe("Scenario ID to auto-enroll on click"),
+    },
+    async ({ name, originalUrl, tagId, scenarioId }) => {
+      try {
+        const client = getClient();
+        const link = await client.trackedLinks.create({
+          name,
+          originalUrl,
+          tagId,
+          scenarioId,
+        });
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify({ success: true, link }, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: false, error: String(error) },
+                null,
+                2,
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/src/tools/enroll-scenario.ts

@@ -0,0 +1,48 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getClient } from "../client.js";
+
+export function registerEnrollScenario(server: McpServer): void {
+  server.tool(
+    "enroll_in_scenario",
+    "Enroll a friend into a scenario. The friend will start receiving the scenario's step messages from step 1.",
+    {
+      scenarioId: z
+        .string()
+        .describe("The scenario ID to enroll the friend in"),
+      friendId: z.string().describe("The friend's ID to enroll"),
+    },
+    async ({ scenarioId, friendId }) => {
+      try {
+        const client = getClient();
+        const enrollment = await client.scenarios.enroll(scenarioId, friendId);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: true, enrollment },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: false, error: String(error) },
+                null,
+                2,
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/src/tools/get-form-submissions.ts

@@ -0,0 +1,45 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getClient } from "../client.js";
+
+export function registerGetFormSubmissions(server: McpServer): void {
+  server.tool(
+    "get_form_submissions",
+    "Get all submissions for a specific form. Returns response data with timestamps and friend IDs.",
+    {
+      formId: z.string().describe("The form ID to get submissions for"),
+    },
+    async ({ formId }) => {
+      try {
+        const client = getClient();
+        const submissions = await client.forms.getSubmissions(formId);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: true, submissions },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: false, error: String(error) },
+                null,
+                2,
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/src/tools/get-friend-detail.ts

@@ -0,0 +1,41 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getClient } from "../client.js";
+
+export function registerGetFriendDetail(server: McpServer): void {
+  server.tool(
+    "get_friend_detail",
+    "Get detailed information about a specific friend including tags, metadata, and profile.",
+    {
+      friendId: z.string().describe("The friend's ID"),
+    },
+    async ({ friendId }) => {
+      try {
+        const client = getClient();
+        const friend = await client.friends.get(friendId);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify({ success: true, friend }, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: false, error: String(error) },
+                null,
+                2,
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/src/tools/get-link-clicks.ts

@@ -0,0 +1,41 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getClient } from "../client.js";
+
+export function registerGetLinkClicks(server: McpServer): void {
+  server.tool(
+    "get_link_clicks",
+    "Get click analytics for a tracked link including total clicks and per-friend click history.",
+    {
+      linkId: z.string().describe("The tracked link ID"),
+    },
+    async ({ linkId }) => {
+      try {
+        const client = getClient();
+        const link = await client.trackedLinks.get(linkId);
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify({ success: true, link }, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: false, error: String(error) },
+                null,
+                2,
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/src/tools/index.ts

@@ -0,0 +1,32 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerSendMessage } from "./send-message.js";
+import { registerBroadcast } from "./broadcast.js";
+import { registerCreateScenario } from "./create-scenario.js";
+import { registerEnrollScenario } from "./enroll-scenario.js";
+import { registerManageTags } from "./manage-tags.js";
+import { registerCreateForm } from "./create-form.js";
+import { registerCreateTrackedLink } from "./create-tracked-link.js";
+import { registerCreateRichMenu } from "./create-rich-menu.js";
+import { registerListFriends } from "./list-friends.js";
+import { registerGetFriendDetail } from "./get-friend-detail.js";
+import { registerGetFormSubmissions } from "./get-form-submissions.js";
+import { registerGetLinkClicks } from "./get-link-clicks.js";
+import { registerAccountSummary } from "./account-summary.js";
+import { registerListCrmObjects } from "./list-crm-objects.js";
+
+export function registerAllTools(server: McpServer): void {
+  registerSendMessage(server);
+  registerBroadcast(server);
+  registerCreateScenario(server);
+  registerEnrollScenario(server);
+  registerManageTags(server);
+  registerCreateForm(server);
+  registerCreateTrackedLink(server);
+  registerCreateRichMenu(server);
+  registerListFriends(server);
+  registerGetFriendDetail(server);
+  registerGetFormSubmissions(server);
+  registerGetLinkClicks(server);
+  registerAccountSummary(server);
+  registerListCrmObjects(server);
+}

package/src/tools/list-crm-objects.ts

@@ -0,0 +1,80 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getClient } from "../client.js";
+
+export function registerListCrmObjects(server: McpServer): void {
+  server.tool(
+    "list_crm_objects",
+    "List all CRM objects of a specific type: scenarios, forms, tags, rich menus, tracked links, or broadcasts.",
+    {
+      objectType: z
+        .enum([
+          "scenarios",
+          "forms",
+          "tags",
+          "rich_menus",
+          "tracked_links",
+          "broadcasts",
+        ])
+        .describe("Type of CRM object to list"),
+      accountId: z
+        .string()
+        .optional()
+        .describe("LINE account ID (uses default if omitted)"),
+    },
+    async ({ objectType, accountId }) => {
+      try {
+        const client = getClient();
+        let items: unknown;
+
+        switch (objectType) {
+          case "scenarios":
+            items = await client.scenarios.list({ accountId });
+            break;
+          case "forms":
+            items = await client.forms.list();
+            break;
+          case "tags":
+            items = await client.tags.list();
+            break;
+          case "rich_menus":
+            items = await client.richMenus.list();
+            break;
+          case "tracked_links":
+            items = await client.trackedLinks.list();
+            break;
+          case "broadcasts":
+            items = await client.broadcasts.list({ accountId });
+            break;
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: true, objectType, items },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: false, error: String(error) },
+                null,
+                2,
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/src/tools/list-friends.ts

@@ -0,0 +1,64 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getClient } from "../client.js";
+
+export function registerListFriends(server: McpServer): void {
+  server.tool(
+    "list_friends",
+    "List friends with optional filtering by tag. Returns paginated results with friend details.",
+    {
+      tagId: z.string().optional().describe("Filter by tag ID"),
+      limit: z
+        .number()
+        .default(20)
+        .describe("Number of friends to return (max 100)"),
+      offset: z.number().default(0).describe("Offset for pagination"),
+      accountId: z
+        .string()
+        .optional()
+        .describe("LINE account ID (uses default if omitted)"),
+    },
+    async ({ tagId, limit, offset, accountId }) => {
+      try {
+        const client = getClient();
+        const result = await client.friends.list({
+          tagId,
+          limit,
+          offset,
+          accountId,
+        });
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                {
+                  success: true,
+                  total: result.total,
+                  hasNextPage: result.hasNextPage,
+                  friends: result.items,
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: false, error: String(error) },
+                null,
+                2,
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+}