@line-harness/mcp-server 0.2.2 → 0.4.0

package/package.json

@@ -1,37 +1,22 @@
 {
   "name": "@line-harness/mcp-server",
-  "version": "0.2.2",
-  "description": "MCP Server for LINE Harness — operate LINE official accounts from any AI tool",
+  "version": "0.4.0",
   "type": "module",
-  "main": "./dist/index.js",
   "bin": {
     "line-harness-mcp": "./dist/index.js"
   },
+  "main": "./dist/index.js",
   "scripts": {
-    "build": "npx esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@modelcontextprotocol/sdk --external:zod && chmod 755 dist/index.js",
-    "dev": "tsc --watch",
-    "start": "node dist/index.js"
-  },
-  "keywords": [
-    "mcp",
-    "line",
-    "crm",
-    "ai"
-  ],
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
+    "build": "tsup",
+    "dev": "tsup --watch"
   },
-  "files": [
-    "dist",
-    "README.md"
-  ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "zod": "^3.23.0"
+    "@line-harness/sdk": "workspace:*",
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.4"
   },
   "devDependencies": {
-    "typescript": "^5.5.0",
-    "@types/node": "^20.0.0"
+    "tsup": "^8.4.0",
+    "typescript": "^5.9.3"
   }
 }

package/src/client.ts

@@ -0,0 +1,26 @@
+import { LineHarness } from "@line-harness/sdk";
+
+let clientInstance: LineHarness | null = null;
+
+export function getClient(): LineHarness {
+  if (clientInstance) return clientInstance;
+
+  const apiUrl = process.env.LINE_HARNESS_API_URL;
+  const apiKey = process.env.LINE_HARNESS_API_KEY;
+  const accountId = process.env.LINE_HARNESS_ACCOUNT_ID;
+
+  if (!apiUrl) {
+    throw new Error("LINE_HARNESS_API_URL environment variable is required");
+  }
+  if (!apiKey) {
+    throw new Error("LINE_HARNESS_API_KEY environment variable is required");
+  }
+
+  clientInstance = new LineHarness({
+    apiUrl,
+    apiKey,
+    lineAccountId: accountId,
+  });
+
+  return clientInstance;
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerAllTools } from "./tools/index.js";
+import { registerAllResources } from "./resources/index.js";
+
+const server = new McpServer({
+  name: "line-harness",
+  version: "0.3.0",
+});
+
+registerAllTools(server);
+registerAllResources(server);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("LINE Harness MCP Server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/src/resources/index.ts

@@ -0,0 +1,80 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { getClient } from "../client.js";
+
+export function registerAllResources(server: McpServer): void {
+  server.resource(
+    "Account Summary",
+    "line-harness://account/summary",
+    async (_uri) => {
+      const client = getClient();
+      const [friendCount, scenarios, tags] = await Promise.all([
+        client.friends.count(),
+        client.scenarios.list(),
+        client.tags.list(),
+      ]);
+
+      const summary = {
+        friends: friendCount,
+        activeScenarios: scenarios.filter(
+          (s: { isActive: boolean }) => s.isActive,
+        ).length,
+        totalScenarios: scenarios.length,
+        tags: tags.map((t: { id: string; name: string }) => ({
+          id: t.id,
+          name: t.name,
+        })),
+      };
+
+      return {
+        contents: [
+          {
+            uri: "line-harness://account/summary",
+            mimeType: "application/json",
+            text: JSON.stringify(summary, null, 2),
+          },
+        ],
+      };
+    },
+  );
+
+  server.resource(
+    "Active Scenarios",
+    "line-harness://scenarios/active",
+    async (_uri) => {
+      const client = getClient();
+      const scenarios = await client.scenarios.list();
+      const active = scenarios.filter(
+        (s: { isActive: boolean }) => s.isActive,
+      );
+
+      return {
+        contents: [
+          {
+            uri: "line-harness://scenarios/active",
+            mimeType: "application/json",
+            text: JSON.stringify(active, null, 2),
+          },
+        ],
+      };
+    },
+  );
+
+  server.resource(
+    "Tags List",
+    "line-harness://tags/list",
+    async (_uri) => {
+      const client = getClient();
+      const tags = await client.tags.list();
+
+      return {
+        contents: [
+          {
+            uri: "line-harness://tags/list",
+            mimeType: "application/json",
+            text: JSON.stringify(tags, null, 2),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/tools/account-summary.ts

@@ -0,0 +1,178 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getClient } from "../client.js";
+
+interface AccountInfo {
+  id: string;
+  name: string;
+  channelId: string;
+}
+
+interface AccountStat {
+  id: string;
+  name: string;
+  channelId: string;
+  friendsInDb: number;
+  riskLevel?: string;
+}
+
+export function registerAccountSummary(server: McpServer): void {
+  server.tool(
+    "account_summary",
+    "Get a high-level summary of the LINE account: friend count per account (DB + LINE API stats), active scenarios, recent broadcasts, tags, and forms. Use this to understand the current state before making changes.",
+    {
+      accountId: z
+        .string()
+        .optional()
+        .describe("LINE account ID (uses default if omitted)"),
+    },
+    async ({ accountId }) => {
+      try {
+        const client = getClient();
+        const apiUrl = process.env.LINE_HARNESS_API_URL;
+        const apiKey = process.env.LINE_HARNESS_API_KEY;
+
+        // Fetch all LINE accounts
+        const accountsRes = await fetch(`${apiUrl}/api/line-accounts`, {
+          headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        const accountsData = (await accountsRes.json()) as {
+          success: boolean;
+          data: AccountInfo[];
+        };
+        const accounts: AccountInfo[] = accountsData.success
+          ? accountsData.data
+          : [];
+
+        // Get per-account friend counts
+        const accountStats: AccountStat[] = [];
+        for (const acc of accounts) {
+          // Use direct API call for per-account count (SDK count() has no params)
+          const countRes = await fetch(
+            `${apiUrl}/api/friends/count?lineAccountId=${encodeURIComponent(acc.id)}`,
+            { headers: { Authorization: `Bearer ${apiKey}` } },
+          );
+          const countData = (await countRes.json()) as {
+            success: boolean;
+            data: { count: number };
+          };
+          const count = countData.success ? countData.data.count : 0;
+          accountStats.push({
+            id: acc.id,
+            name: acc.name,
+            channelId: acc.channelId,
+            friendsInDb: count,
+          });
+        }
+
+        // Get health/risk level for each account
+        for (const acc of accountStats) {
+          try {
+            const healthRes = await fetch(
+              `${apiUrl}/api/accounts/${acc.id}/health`,
+              { headers: { Authorization: `Bearer ${apiKey}` } },
+            );
+            const healthData = (await healthRes.json()) as {
+              success: boolean;
+              data: { riskLevel: string };
+            };
+            if (healthData.success) {
+              acc.riskLevel = healthData.data.riskLevel;
+            }
+          } catch {
+            // Health endpoint may not exist yet
+          }
+        }
+
+        const [totalFriends, scenarios, broadcasts, tags, forms] =
+          await Promise.all([
+            client.friends.count(),
+            client.scenarios.list({ accountId }),
+            client.broadcasts.list({ accountId }),
+            client.tags.list(),
+            client.forms.list(),
+          ]);
+
+        const activeScenarios = scenarios.filter(
+          (s: { isActive: boolean }) => s.isActive,
+        );
+        const recentBroadcasts = broadcasts.slice(0, 5);
+
+        const summary = {
+          friends: {
+            totalDbRecords: totalFriends,
+            note: "totalDbRecords includes both Account \u2460 and \u2461 records. Same user on different accounts = separate records. Use per-account counts below for accurate numbers.",
+            perAccount: accountStats,
+          },
+          scenarios: {
+            total: scenarios.length,
+            active: activeScenarios.length,
+            activeList: activeScenarios.map(
+              (s: { id: string; name: string; triggerType: string }) => ({
+                id: s.id,
+                name: s.name,
+                triggerType: s.triggerType,
+              }),
+            ),
+          },
+          broadcasts: {
+            total: broadcasts.length,
+            recent: recentBroadcasts.map(
+              (b: {
+                id: string;
+                title: string;
+                status: string;
+                sentAt: string | null;
+              }) => ({
+                id: b.id,
+                title: b.title,
+                status: b.status,
+                sentAt: b.sentAt,
+              }),
+            ),
+          },
+          tags: {
+            total: tags.length,
+            list: tags.map((t: { id: string; name: string }) => ({
+              id: t.id,
+              name: t.name,
+            })),
+          },
+          forms: {
+            total: forms.length,
+            list: forms.map(
+              (f: { id: string; name: string; submitCount: number }) => ({
+                id: f.id,
+                name: f.name,
+                submitCount: f.submitCount,
+              }),
+            ),
+          },
+        };
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(summary, 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/broadcast.ts

@@ -0,0 +1,195 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getClient } from "../client.js";
+
+export function registerBroadcast(server: McpServer): void {
+  server.tool(
+    "broadcast",
+    "Send a broadcast message to all friends, a specific tag group, or a filtered segment. Creates and immediately sends the broadcast.",
+    {
+      title: z
+        .string()
+        .describe("Internal title for this broadcast (not shown to users)"),
+      messageType: z.enum(["text", "flex"]).describe("Message type"),
+      messageContent: z
+        .string()
+        .describe(
+          "Message content. For text: plain string. For flex: JSON string.",
+        ),
+      targetType: z
+        .enum(["all", "tag", "segment"])
+        .default("all")
+        .describe(
+          "Target audience: 'all' for everyone, 'tag' for a tag group, 'segment' for filtered conditions",
+        ),
+      targetTagId: z
+        .string()
+        .optional()
+        .describe("Tag ID when targetType is 'tag'"),
+      segmentConditions: z
+        .string()
+        .optional()
+        .describe(
+          "JSON string of segment conditions when targetType is 'segment'. Format: { operator: 'AND'|'OR', rules: [{ type: 'tag_exists'|'tag_not_exists'|'metadata_equals'|'metadata_not_equals'|'ref_code'|'is_following', value: string|boolean|{key,value} }] }",
+        ),
+      scheduledAt: z
+        .string()
+        .optional()
+        .describe("ISO 8601 datetime to schedule. Omit to send immediately."),
+      accountId: z
+        .string()
+        .optional()
+        .describe("LINE account ID (uses default if omitted)"),
+    },
+    async ({
+      title,
+      messageType,
+      messageContent,
+      targetType,
+      targetTagId,
+      segmentConditions,
+      scheduledAt,
+      accountId,
+    }) => {
+      try {
+        const client = getClient();
+
+        if (targetType === "segment" && !segmentConditions) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify(
+                  {
+                    success: false,
+                    error:
+                      "segmentConditions is required when targetType is 'segment'",
+                  },
+                  null,
+                  2,
+                ),
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        if (targetType === "segment" && scheduledAt) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify(
+                  {
+                    success: false,
+                    error:
+                      "Scheduled segment broadcasts are not supported. Use scheduledAt only with targetType 'all' or 'tag'.",
+                  },
+                  null,
+                  2,
+                ),
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        if (targetType === "segment" && segmentConditions) {
+          let parsedConditions;
+          try {
+            parsedConditions = JSON.parse(segmentConditions);
+          } catch {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: JSON.stringify(
+                    {
+                      success: false,
+                      error: "segmentConditions must be valid JSON",
+                    },
+                    null,
+                    2,
+                  ),
+                },
+              ],
+              isError: true,
+            };
+          }
+
+          const broadcast = await client.broadcasts.create({
+            title: `[SEGMENT] ${title}`,
+            messageType,
+            messageContent,
+            targetType: "all",
+            lineAccountId: accountId,
+          });
+
+          try {
+            const result = await client.broadcasts.sendToSegment(
+              broadcast.id,
+              parsedConditions,
+            );
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: JSON.stringify(
+                    { success: true, broadcast: result },
+                    null,
+                    2,
+                  ),
+                },
+              ],
+            };
+          } catch (sendError) {
+            await client.broadcasts.delete(broadcast.id).catch(() => {});
+            throw sendError;
+          }
+        }
+
+        // At this point targetType is guaranteed to be 'all' or 'tag' (segment handled above)
+        const broadcast = await client.broadcasts.create({
+          title,
+          messageType,
+          messageContent,
+          targetType: targetType as "all" | "tag",
+          targetTagId,
+          scheduledAt,
+          lineAccountId: accountId,
+        });
+
+        const result = scheduledAt
+          ? broadcast
+          : await client.broadcasts.send(broadcast.id);
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: true, broadcast: result },
+                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-form.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 registerCreateForm(server: McpServer): void {
+  server.tool(
+    "create_form",
+    "Create a form for collecting user responses. Can auto-tag responders and enroll them in scenarios.",
+    {
+      name: z.string().describe("Form name"),
+      description: z
+        .string()
+        .optional()
+        .describe("Form description shown to users"),
+      fields: z
+        .string()
+        .describe(
+          "JSON string of form fields. Format: [{ name: string, label: string, type: 'text'|'email'|'tel'|'number'|'textarea'|'select'|'radio'|'checkbox'|'date', required?: boolean, options?: string[], placeholder?: string }]",
+        ),
+      onSubmitTagId: z
+        .string()
+        .optional()
+        .describe("Tag ID to auto-apply when form is submitted"),
+      onSubmitScenarioId: z
+        .string()
+        .optional()
+        .describe("Scenario ID to auto-enroll when form is submitted"),
+      saveToMetadata: z
+        .boolean()
+        .default(true)
+        .describe("Save form responses to friend metadata"),
+      accountId: z
+        .string()
+        .optional()
+        .describe("LINE account ID (uses default if omitted)"),
+    },
+    async ({
+      name,
+      description,
+      fields,
+      onSubmitTagId,
+      onSubmitScenarioId,
+      saveToMetadata,
+    }) => {
+      try {
+        const client = getClient();
+        const form = await client.forms.create({
+          name,
+          description,
+          fields: JSON.parse(fields),
+          onSubmitTagId,
+          onSubmitScenarioId,
+          saveToMetadata,
+        });
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify({ success: true, form }, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                { success: false, error: String(error) },
+                null,
+                2,
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+}