@line-harness/mcp-server 0.1.1 → 0.2.1

package/dist/index.js

@@ -1,21 +1,1077 @@
 #!/usr/bin/env node
+
+// src/index.ts
 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.1.0",
+
+// src/tools/send-message.ts
+import { z } from "zod";
+
+// ../sdk/dist/index.mjs
+var LineHarnessError = class extends Error {
+  constructor(message, status, endpoint) {
+    super(message);
+    this.status = status;
+    this.endpoint = endpoint;
+    this.name = "LineHarnessError";
+  }
+};
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout;
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const options = {
+      method,
+      headers,
+      signal: AbortSignal.timeout(this.timeout)
+    };
+    if (body !== void 0) {
+      options.body = JSON.stringify(body);
+    }
+    const res = await fetch(url, options);
+    if (!res.ok) {
+      let errorMessage = `HTTP ${res.status}`;
+      try {
+        const errorBody = await res.json();
+        if (errorBody.error) errorMessage = errorBody.error;
+      } catch {
+      }
+      throw new LineHarnessError(errorMessage, res.status, `${method} ${path}`);
+    }
+    return res.json();
+  }
+};
+var FriendsResource = class {
+  constructor(http, defaultAccountId) {
+    this.http = http;
+    this.defaultAccountId = defaultAccountId;
+  }
+  async list(params) {
+    const query = new URLSearchParams();
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    if (params?.offset !== void 0) query.set("offset", String(params.offset));
+    if (params?.tagId) query.set("tagId", params.tagId);
+    const accountId = params?.accountId ?? this.defaultAccountId;
+    if (accountId) query.set("lineAccountId", accountId);
+    const qs = query.toString();
+    const path = qs ? `/api/friends?${qs}` : "/api/friends";
+    const res = await this.http.get(path);
+    return res.data;
+  }
+  async get(id) {
+    const res = await this.http.get(`/api/friends/${id}`);
+    return res.data;
+  }
+  async count(params) {
+    const accountId = params?.accountId ?? this.defaultAccountId;
+    const path = accountId ? `/api/friends/count?lineAccountId=${encodeURIComponent(accountId)}` : "/api/friends/count";
+    const res = await this.http.get(path);
+    return res.data.count;
+  }
+  async addTag(friendId, tagId) {
+    await this.http.post(`/api/friends/${friendId}/tags`, { tagId });
+  }
+  async removeTag(friendId, tagId) {
+    await this.http.delete(`/api/friends/${friendId}/tags/${tagId}`);
+  }
+  async sendMessage(friendId, content, messageType = "text") {
+    const res = await this.http.post(`/api/friends/${friendId}/messages`, {
+      messageType,
+      content
+    });
+    return res.data;
+  }
+  async setMetadata(friendId, fields) {
+    const res = await this.http.put(`/api/friends/${friendId}/metadata`, fields);
+    return res.data;
+  }
+  async setRichMenu(friendId, richMenuId) {
+    await this.http.post(`/api/friends/${friendId}/rich-menu`, { richMenuId });
+  }
+  async removeRichMenu(friendId) {
+    await this.http.delete(`/api/friends/${friendId}/rich-menu`);
+  }
+};
+var TagsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const res = await this.http.get("/api/tags");
+    return res.data;
+  }
+  async create(input) {
+    const res = await this.http.post("/api/tags", input);
+    return res.data;
+  }
+  async delete(id) {
+    await this.http.delete(`/api/tags/${id}`);
+  }
+};
+var ScenariosResource = class {
+  constructor(http, defaultAccountId) {
+    this.http = http;
+    this.defaultAccountId = defaultAccountId;
+  }
+  async list(params) {
+    const accountId = params?.accountId ?? this.defaultAccountId;
+    const query = accountId ? `?lineAccountId=${accountId}` : "";
+    const res = await this.http.get(`/api/scenarios${query}`);
+    return res.data;
+  }
+  async get(id) {
+    const res = await this.http.get(`/api/scenarios/${id}`);
+    return res.data;
+  }
+  async create(input) {
+    const body = { ...input };
+    if (!body.lineAccountId && this.defaultAccountId) {
+      body.lineAccountId = this.defaultAccountId;
+    }
+    const res = await this.http.post("/api/scenarios", body);
+    return res.data;
+  }
+  async update(id, input) {
+    const res = await this.http.put(`/api/scenarios/${id}`, input);
+    return res.data;
+  }
+  async delete(id) {
+    await this.http.delete(`/api/scenarios/${id}`);
+  }
+  async addStep(scenarioId, input) {
+    const res = await this.http.post(`/api/scenarios/${scenarioId}/steps`, input);
+    return res.data;
+  }
+  async updateStep(scenarioId, stepId, input) {
+    const res = await this.http.put(`/api/scenarios/${scenarioId}/steps/${stepId}`, input);
+    return res.data;
+  }
+  async deleteStep(scenarioId, stepId) {
+    await this.http.delete(`/api/scenarios/${scenarioId}/steps/${stepId}`);
+  }
+  async enroll(scenarioId, friendId) {
+    const res = await this.http.post(
+      `/api/scenarios/${scenarioId}/enroll/${friendId}`
+    );
+    return res.data;
+  }
+};
+var BroadcastsResource = class {
+  constructor(http, defaultAccountId) {
+    this.http = http;
+    this.defaultAccountId = defaultAccountId;
+  }
+  async list(params) {
+    const accountId = params?.accountId ?? this.defaultAccountId;
+    const query = accountId ? `?lineAccountId=${accountId}` : "";
+    const res = await this.http.get(`/api/broadcasts${query}`);
+    return res.data;
+  }
+  async get(id) {
+    const res = await this.http.get(`/api/broadcasts/${id}`);
+    return res.data;
+  }
+  async create(input) {
+    const body = { ...input };
+    if (!body.lineAccountId && this.defaultAccountId) {
+      body.lineAccountId = this.defaultAccountId;
+    }
+    const res = await this.http.post("/api/broadcasts", body);
+    return res.data;
+  }
+  async update(id, input) {
+    const res = await this.http.put(`/api/broadcasts/${id}`, input);
+    return res.data;
+  }
+  async delete(id) {
+    await this.http.delete(`/api/broadcasts/${id}`);
+  }
+  async send(id) {
+    const res = await this.http.post(`/api/broadcasts/${id}/send`);
+    return res.data;
+  }
+  async sendToSegment(id, conditions) {
+    const res = await this.http.post(
+      `/api/broadcasts/${id}/send-segment`,
+      { conditions }
+    );
+    return res.data;
+  }
+};
+var RichMenusResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const res = await this.http.get("/api/rich-menus");
+    return res.data;
+  }
+  async create(menu) {
+    const res = await this.http.post("/api/rich-menus", menu);
+    return res.data;
+  }
+  async delete(richMenuId) {
+    await this.http.delete(`/api/rich-menus/${encodeURIComponent(richMenuId)}`);
+  }
+  async setDefault(richMenuId) {
+    await this.http.post(`/api/rich-menus/${encodeURIComponent(richMenuId)}/default`);
+  }
+};
+var TrackedLinksResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const res = await this.http.get("/api/tracked-links");
+    return res.data;
+  }
+  async create(input) {
+    const res = await this.http.post("/api/tracked-links", input);
+    return res.data;
+  }
+  async get(id) {
+    const res = await this.http.get(`/api/tracked-links/${id}`);
+    return res.data;
+  }
+  async delete(id) {
+    await this.http.delete(`/api/tracked-links/${id}`);
+  }
+};
+var FormsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const res = await this.http.get("/api/forms");
+    return res.data;
+  }
+  async get(id) {
+    const res = await this.http.get(`/api/forms/${id}`);
+    return res.data;
+  }
+  async create(input) {
+    const res = await this.http.post("/api/forms", input);
+    return res.data;
+  }
+  async update(id, input) {
+    const res = await this.http.put(`/api/forms/${id}`, input);
+    return res.data;
+  }
+  async delete(id) {
+    await this.http.delete(`/api/forms/${id}`);
+  }
+  async getSubmissions(formId) {
+    const res = await this.http.get(
+      `/api/forms/${formId}/submissions`
+    );
+    return res.data;
+  }
+};
+var MULTIPLIERS = {
+  m: 1,
+  h: 60,
+  d: 1440,
+  w: 10080
+};
+function parseDelay(input) {
+  const match = input.match(/^(\d+)([mhdw])$/);
+  if (!match) {
+    throw new Error(`Invalid delay format: "${input}". Use format like "30m", "1h", "1d", "1w".`);
+  }
+  return Number(match[1]) * MULTIPLIERS[match[2]];
+}
+var Workflows = class {
+  constructor(friends, scenarios, broadcasts) {
+    this.friends = friends;
+    this.scenarios = scenarios;
+    this.broadcasts = broadcasts;
+  }
+  async createStepScenario(name, triggerType, steps) {
+    const scenario = await this.scenarios.create({ name, triggerType });
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      await this.scenarios.addStep(scenario.id, {
+        stepOrder: i + 1,
+        delayMinutes: parseDelay(step.delay),
+        messageType: step.type,
+        messageContent: step.content
+      });
+    }
+    return this.scenarios.get(scenario.id);
+  }
+  async broadcastText(text) {
+    const broadcast = await this.broadcasts.create({
+      title: text.slice(0, 50),
+      messageType: "text",
+      messageContent: text,
+      targetType: "all"
+    });
+    return this.broadcasts.send(broadcast.id);
+  }
+  async broadcastToTag(tagId, messageType, content) {
+    const broadcast = await this.broadcasts.create({
+      title: content.slice(0, 50),
+      messageType,
+      messageContent: content,
+      targetType: "tag",
+      targetTagId: tagId
+    });
+    return this.broadcasts.send(broadcast.id);
+  }
+  async broadcastToSegment(messageType, content, conditions) {
+    const broadcast = await this.broadcasts.create({
+      title: content.slice(0, 50),
+      messageType,
+      messageContent: content,
+      targetType: "all"
+    });
+    return this.broadcasts.sendToSegment(broadcast.id, conditions);
+  }
+  async sendTextToFriend(friendId, text) {
+    return this.friends.sendMessage(friendId, text, "text");
+  }
+  async sendFlexToFriend(friendId, flexJson) {
+    return this.friends.sendMessage(friendId, flexJson, "flex");
+  }
+};
+var LineHarness = class {
+  friends;
+  tags;
+  scenarios;
+  broadcasts;
+  richMenus;
+  trackedLinks;
+  forms;
+  apiUrl;
+  defaultAccountId;
+  workflows;
+  createStepScenario;
+  broadcastText;
+  broadcastToTag;
+  broadcastToSegment;
+  sendTextToFriend;
+  sendFlexToFriend;
+  constructor(config) {
+    this.apiUrl = config.apiUrl.replace(/\/$/, "");
+    this.defaultAccountId = config.lineAccountId;
+    const http = new HttpClient({
+      baseUrl: this.apiUrl,
+      apiKey: config.apiKey,
+      timeout: config.timeout ?? 3e4
+    });
+    this.friends = new FriendsResource(http, this.defaultAccountId);
+    this.tags = new TagsResource(http);
+    this.scenarios = new ScenariosResource(http, this.defaultAccountId);
+    this.broadcasts = new BroadcastsResource(http, this.defaultAccountId);
+    this.richMenus = new RichMenusResource(http);
+    this.trackedLinks = new TrackedLinksResource(http);
+    this.forms = new FormsResource(http);
+    this.workflows = new Workflows(this.friends, this.scenarios, this.broadcasts);
+    this.createStepScenario = this.workflows.createStepScenario.bind(this.workflows);
+    this.broadcastText = this.workflows.broadcastText.bind(this.workflows);
+    this.broadcastToTag = this.workflows.broadcastToTag.bind(this.workflows);
+    this.broadcastToSegment = this.workflows.broadcastToSegment.bind(this.workflows);
+    this.sendTextToFriend = this.workflows.sendTextToFriend.bind(this.workflows);
+    this.sendFlexToFriend = this.workflows.sendFlexToFriend.bind(this.workflows);
+  }
+  /**
+   * Generate friend-add URL with OAuth (bot_prompt=aggressive)
+   * This URL does friend-add + UUID in one step.
+   *
+   * @param ref - Attribution code (e.g., 'lp-a', 'instagram', 'seminar-0322')
+   * @param redirect - URL to redirect after completion
+   */
+  getAuthUrl(options) {
+    const url = new URL(`${this.apiUrl}/auth/line`);
+    if (options?.ref) url.searchParams.set("ref", options.ref);
+    if (options?.redirect) url.searchParams.set("redirect", options.redirect);
+    return url.toString();
+  }
+};
+
+// src/client.ts
+var clientInstance = null;
+function getClient() {
+  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;
+}
+
+// src/tools/send-message.ts
+function registerSendMessage(server2) {
+  server2.tool(
+    "send_message",
+    "Send a text or flex message to a specific friend. Use messageType 'flex' for rich card layouts.",
+    {
+      friendId: z.string().describe("The friend's ID to send the message to"),
+      content: z.string().describe("Message content. For text: plain string. For flex: JSON string of LINE Flex Message."),
+      messageType: z.enum(["text", "flex"]).default("text").describe("Message type: 'text' for plain text, 'flex' for Flex Message JSON")
+    },
+    async ({ friendId, content, messageType }) => {
+      try {
+        const client = getClient();
+        const result = await client.friends.sendMessage(friendId, content, messageType);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ success: true, messageId: result.messageId }, null, 2)
+          }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/broadcast.ts
+import { z as z2 } from "zod";
+function registerBroadcast(server2) {
+  server2.tool(
+    "broadcast",
+    "Send a broadcast message to all friends, a specific tag group, or a filtered segment. Creates and immediately sends the broadcast.",
+    {
+      title: z2.string().describe("Internal title for this broadcast (not shown to users)"),
+      messageType: z2.enum(["text", "flex"]).describe("Message type"),
+      messageContent: z2.string().describe("Message content. For text: plain string. For flex: JSON string."),
+      targetType: z2.enum(["all", "tag", "segment"]).default("all").describe("Target audience: 'all' for everyone, 'tag' for a tag group, 'segment' for filtered conditions"),
+      targetTagId: z2.string().optional().describe("Tag ID when targetType is 'tag'"),
+      segmentConditions: z2.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: z2.string().optional().describe("ISO 8601 datetime to schedule. Omit to send immediately."),
+      accountId: z2.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", 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", 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", text: JSON.stringify({ success: false, error: "segmentConditions must be valid JSON" }, null, 2) }],
+              isError: true
+            };
+          }
+          const broadcast2 = await client.broadcasts.create({
+            title: `[SEGMENT] ${title}`,
+            messageType,
+            messageContent,
+            targetType: "all",
+            lineAccountId: accountId
+          });
+          try {
+            const result2 = await client.broadcasts.sendToSegment(broadcast2.id, parsedConditions);
+            return { content: [{ type: "text", text: JSON.stringify({ success: true, broadcast: result2 }, null, 2) }] };
+          } catch (sendError) {
+            await client.broadcasts.delete(broadcast2.id).catch(() => {
+            });
+            throw sendError;
+          }
+        }
+        const broadcast = await client.broadcasts.create({
+          title,
+          messageType,
+          messageContent,
+          targetType,
+          targetTagId,
+          scheduledAt,
+          lineAccountId: accountId
+        });
+        const result = scheduledAt ? broadcast : await client.broadcasts.send(broadcast.id);
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, broadcast: result }, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/create-scenario.ts
+import { z as z3 } from "zod";
+function registerCreateScenario(server2) {
+  server2.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: z3.string().describe("Scenario name"),
+      triggerType: z3.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: z3.string().optional().describe("Required when triggerType is 'tag_added': the tag ID that triggers this scenario"),
+      steps: z3.array(z3.object({
+        delay: z3.string().describe("Delay before sending. Format: '0m' for immediate, '30m' for 30 minutes, '24h' for 24 hours"),
+        type: z3.enum(["text", "flex"]).describe("Message type"),
+        content: z3.string().describe("Message content")
+      })).describe("Ordered list of message steps"),
+      accountId: z3.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", text: JSON.stringify({ success: false, error: "triggerTagId is required when triggerType is 'tag_added'" }, null, 2) }],
+            isError: true
+          };
+        }
+        const parsedSteps = [];
+        for (let i = 0; i < steps.length; i++) {
+          const step = steps[i];
+          let delayMinutes;
+          try {
+            delayMinutes = parseDelay(step.delay);
+          } catch {
+            return {
+              content: [{ type: "text", 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",
+            text: JSON.stringify({ success: true, scenario: scenarioWithSteps }, null, 2)
+          }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/enroll-scenario.ts
+import { z as z4 } from "zod";
+function registerEnrollScenario(server2) {
+  server2.tool(
+    "enroll_in_scenario",
+    "Enroll a friend into a scenario. The friend will start receiving the scenario's step messages from step 1.",
+    {
+      scenarioId: z4.string().describe("The scenario ID to enroll the friend in"),
+      friendId: z4.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",
+            text: JSON.stringify({ success: true, enrollment }, null, 2)
+          }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/manage-tags.ts
+import { z as z5 } from "zod";
+function registerManageTags(server2) {
+  server2.tool(
+    "manage_tags",
+    "Create tags, add tags to friends, or remove tags from friends. Supports batch operations on multiple friends.",
+    {
+      action: z5.enum(["create", "add", "remove"]).describe("Action to perform"),
+      tagName: z5.string().optional().describe("Tag name (for 'create' action)"),
+      tagColor: z5.string().optional().describe("Tag color hex code (for 'create' action, e.g. '#FF0000')"),
+      tagId: z5.string().optional().describe("Tag ID (for 'add' or 'remove' actions)"),
+      friendIds: z5.array(z5.string()).optional().describe("Friend IDs to add/remove the tag from (for 'add' or 'remove' actions)")
+    },
+    async ({ action, tagName, tagColor, tagId, friendIds }) => {
+      try {
+        const client = getClient();
+        if (action === "create") {
+          if (!tagName) throw new Error("tagName is required for create action");
+          const tag = await client.tags.create({ name: tagName, color: tagColor });
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: true, tag }, null, 2) }]
+          };
+        }
+        if (!tagId) throw new Error("tagId is required for add/remove actions");
+        if (!friendIds?.length) throw new Error("friendIds is required for add/remove actions");
+        const results = [];
+        for (const friendId of friendIds) {
+          if (action === "add") {
+            await client.friends.addTag(friendId, tagId);
+          } else {
+            await client.friends.removeTag(friendId, tagId);
+          }
+          results.push({ friendId, status: "ok" });
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, results }, null, 2) }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/create-form.ts
+import { z as z6 } from "zod";
+function registerCreateForm(server2) {
+  server2.tool(
+    "create_form",
+    "Create a form for collecting user responses. Can auto-tag responders and enroll them in scenarios.",
+    {
+      name: z6.string().describe("Form name"),
+      description: z6.string().optional().describe("Form description shown to users"),
+      fields: z6.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: z6.string().optional().describe("Tag ID to auto-apply when form is submitted"),
+      onSubmitScenarioId: z6.string().optional().describe("Scenario ID to auto-enroll when form is submitted"),
+      saveToMetadata: z6.boolean().default(true).describe("Save form responses to friend metadata"),
+      accountId: z6.string().optional().describe("LINE account ID (uses default if omitted)")
+    },
+    async ({ name, description, fields, onSubmitTagId, onSubmitScenarioId, saveToMetadata, accountId }) => {
+      try {
+        const client = getClient();
+        const form = await client.forms.create({
+          name,
+          description,
+          fields: JSON.parse(fields),
+          onSubmitTagId,
+          onSubmitScenarioId,
+          saveToMetadata
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, form }, null, 2) }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/create-tracked-link.ts
+import { z as z7 } from "zod";
+function registerCreateTrackedLink(server2) {
+  server2.tool(
+    "create_tracked_link",
+    "Create a click-tracking link. When clicked, can auto-tag the user and enroll them in a scenario.",
+    {
+      name: z7.string().describe("Link name (internal label)"),
+      originalUrl: z7.string().describe("The destination URL to redirect to"),
+      tagId: z7.string().optional().describe("Tag ID to auto-apply on click"),
+      scenarioId: z7.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", text: JSON.stringify({ success: true, link }, null, 2) }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/create-rich-menu.ts
+import { z as z8 } from "zod";
+function registerCreateRichMenu(server2) {
+  server2.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: z8.string().describe("Rich menu name"),
+      chatBarText: z8.string().default("\u30E1\u30CB\u30E5\u30FC").describe("Text shown on the chat bar button"),
+      size: z8.object({
+        width: z8.number().default(2500).describe("Menu width in pixels (2500 for full-width)"),
+        height: z8.number().default(1686).describe("Menu height: 1686 for full, 843 for half")
+      }).default({ width: 2500, height: 1686 }).describe("Menu size in pixels"),
+      selected: z8.boolean().default(false).describe("Whether the rich menu is displayed by default"),
+      areas: z8.string().describe("JSON string of menu button areas. Format: [{ bounds: { x, y, width, height }, action: { type: 'uri'|'message'|'postback', uri?, text?, data? } }]"),
+      setAsDefault: z8.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", text: JSON.stringify({ success: true, richMenuId: menu.richMenuId, isDefault: setAsDefault }, null, 2) }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/list-friends.ts
+import { z as z9 } from "zod";
+function registerListFriends(server2) {
+  server2.tool(
+    "list_friends",
+    "List friends with optional filtering by tag. Returns paginated results with friend details.",
+    {
+      tagId: z9.string().optional().describe("Filter by tag ID"),
+      limit: z9.number().default(20).describe("Number of friends to return (max 100)"),
+      offset: z9.number().default(0).describe("Offset for pagination"),
+      accountId: z9.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",
+            text: JSON.stringify({
+              success: true,
+              total: result.total,
+              hasNextPage: result.hasNextPage,
+              friends: result.items
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/get-friend-detail.ts
+import { z as z10 } from "zod";
+function registerGetFriendDetail(server2) {
+  server2.tool(
+    "get_friend_detail",
+    "Get detailed information about a specific friend including tags, metadata, and profile.",
+    {
+      friendId: z10.string().describe("The friend's ID")
+    },
+    async ({ friendId }) => {
+      try {
+        const client = getClient();
+        const friend = await client.friends.get(friendId);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, friend }, null, 2) }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/get-form-submissions.ts
+import { z as z11 } from "zod";
+function registerGetFormSubmissions(server2) {
+  server2.tool(
+    "get_form_submissions",
+    "Get all submissions for a specific form. Returns response data with timestamps and friend IDs.",
+    {
+      formId: z11.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", text: JSON.stringify({ success: true, submissions }, null, 2) }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/get-link-clicks.ts
+import { z as z12 } from "zod";
+function registerGetLinkClicks(server2) {
+  server2.tool(
+    "get_link_clicks",
+    "Get click analytics for a tracked link including total clicks and per-friend click history.",
+    {
+      linkId: z12.string().describe("The tracked link ID")
+    },
+    async ({ linkId }) => {
+      try {
+        const client = getClient();
+        const link = await client.trackedLinks.get(linkId);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, link }, null, 2) }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/account-summary.ts
+import { z as z13 } from "zod";
+function registerAccountSummary(server2) {
+  server2.tool(
+    "account_summary",
+    "Get a high-level summary of the LINE account: friend count, active scenarios, recent broadcasts, tags, and forms. Use this to understand the current state before making changes.",
+    {
+      accountId: z13.string().optional().describe("LINE account ID (uses default if omitted)")
+    },
+    async ({ accountId }) => {
+      try {
+        const client = getClient();
+        const [friendCount, scenarios, broadcasts, tags, forms] = await Promise.all([
+          client.friends.count({ accountId }),
+          client.scenarios.list({ accountId }),
+          client.broadcasts.list({ accountId }),
+          client.tags.list(),
+          client.forms.list()
+        ]);
+        const activeScenarios = scenarios.filter((s) => s.isActive);
+        const recentBroadcasts = broadcasts.slice(0, 5);
+        const summary = {
+          friends: { total: friendCount },
+          scenarios: {
+            total: scenarios.length,
+            active: activeScenarios.length,
+            activeList: activeScenarios.map((s) => ({ id: s.id, name: s.name, triggerType: s.triggerType }))
+          },
+          broadcasts: {
+            total: broadcasts.length,
+            recent: recentBroadcasts.map((b) => ({ id: b.id, title: b.title, status: b.status, sentAt: b.sentAt }))
+          },
+          tags: {
+            total: tags.length,
+            list: tags.map((t) => ({ id: t.id, name: t.name }))
+          },
+          forms: {
+            total: forms.length,
+            list: forms.map((f) => ({ id: f.id, name: f.name }))
+          }
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(summary, null, 2) }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/list-crm-objects.ts
+import { z as z14 } from "zod";
+function registerListCrmObjects(server2) {
+  server2.tool(
+    "list_crm_objects",
+    "List all CRM objects of a specific type: scenarios, forms, tags, rich menus, tracked links, or broadcasts.",
+    {
+      objectType: z14.enum(["scenarios", "forms", "tags", "rich_menus", "tracked_links", "broadcasts"]).describe("Type of CRM object to list"),
+      accountId: z14.string().optional().describe("LINE account ID (uses default if omitted)")
+    },
+    async ({ objectType, accountId }) => {
+      try {
+        const client = getClient();
+        let items;
+        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", text: JSON.stringify({ success: true, objectType, items }, null, 2) }]
+        };
+      } catch (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: String(error) }, null, 2) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(server2) {
+  registerSendMessage(server2);
+  registerBroadcast(server2);
+  registerCreateScenario(server2);
+  registerEnrollScenario(server2);
+  registerManageTags(server2);
+  registerCreateForm(server2);
+  registerCreateTrackedLink(server2);
+  registerCreateRichMenu(server2);
+  registerListFriends(server2);
+  registerGetFriendDetail(server2);
+  registerGetFormSubmissions(server2);
+  registerGetLinkClicks(server2);
+  registerAccountSummary(server2);
+  registerListCrmObjects(server2);
+}
+
+// src/resources/index.ts
+function registerAllResources(server2) {
+  server2.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) => s.isActive).length,
+        totalScenarios: scenarios.length,
+        tags: tags.map((t) => ({ id: t.id, name: t.name }))
+      };
+      return {
+        contents: [{
+          uri: "line-harness://account/summary",
+          mimeType: "application/json",
+          text: JSON.stringify(summary, null, 2)
+        }]
+      };
+    }
+  );
+  server2.resource(
+    "Active Scenarios",
+    "line-harness://scenarios/active",
+    async (uri) => {
+      const client = getClient();
+      const scenarios = await client.scenarios.list();
+      const active = scenarios.filter((s) => s.isActive);
+      return {
+        contents: [{
+          uri: "line-harness://scenarios/active",
+          mimeType: "application/json",
+          text: JSON.stringify(active, null, 2)
+        }]
+      };
+    }
+  );
+  server2.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)
+        }]
+      };
+    }
+  );
+}
+
+// src/index.ts
+var server = new McpServer({
+  name: "line-harness",
+  version: "0.1.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");
+  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);
+  console.error("Fatal error:", error);
+  process.exit(1);
 });
-//# sourceMappingURL=index.js.map