@openclaw/line 2026.5.2-beta.1

package/src/channel.ts

@@ -0,0 +1,154 @@
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
+import { createPairingPrefixStripper } from "openclaw/plugin-sdk/channel-pairing";
+import { createRestrictSendersChannelSecurity } from "openclaw/plugin-sdk/channel-policy";
+import { createEmptyChannelDirectoryAdapter } from "openclaw/plugin-sdk/directory-runtime";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { resolveLineAccount } from "./accounts.js";
+import { lineBindingsAdapter } from "./bindings.js";
+import { type ChannelPlugin, type ResolvedLineAccount } from "./channel-api.js";
+import { lineChannelPluginCommon } from "./channel-shared.js";
+import { lineGatewayAdapter } from "./gateway.js";
+import { resolveLineGroupRequireMention } from "./group-policy.js";
+import { lineOutboundAdapter } from "./outbound.js";
+import { hasLineDirectives, parseLineDirectives } from "./reply-payload-transform.js";
+import { getLineRuntime } from "./runtime.js";
+import { lineSetupAdapter } from "./setup-core.js";
+import { lineSetupWizard } from "./setup-surface.js";
+import { lineStatusAdapter } from "./status.js";
+
+const loadLineChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime.js"));
+
+const lineSecurityAdapter = createRestrictSendersChannelSecurity<ResolvedLineAccount>({
+  channelKey: "line",
+  resolveDmPolicy: (account) => account.config.dmPolicy,
+  resolveDmAllowFrom: (account) => account.config.allowFrom,
+  resolveGroupPolicy: (account) => account.config.groupPolicy,
+  surface: "LINE groups",
+  openScope: "any member in groups",
+  groupPolicyPath: "channels.line.groupPolicy",
+  groupAllowFromPath: "channels.line.groupAllowFrom",
+  mentionGated: false,
+  policyPathSuffix: "dmPolicy",
+  approveHint: "openclaw pairing approve line <code>",
+  normalizeDmEntry: (raw) => raw.replace(/^line:(?:user:)?/i, ""),
+});
+
+export const linePlugin: ChannelPlugin<ResolvedLineAccount> = createChatChannelPlugin({
+  base: {
+    id: "line",
+    ...lineChannelPluginCommon,
+    setupWizard: lineSetupWizard,
+    groups: {
+      resolveRequireMention: resolveLineGroupRequireMention,
+    },
+    messaging: {
+      targetPrefixes: ["line"],
+      normalizeTarget: (target) => {
+        const trimmed = target.trim();
+        if (!trimmed) {
+          return undefined;
+        }
+        return trimmed.replace(/^line:(group|room|user):/i, "").replace(/^line:/i, "");
+      },
+      resolveInboundConversation: lineBindingsAdapter.resolveInboundConversation,
+      transformReplyPayload: ({ payload }) => {
+        if (!payload.text || !hasLineDirectives(payload.text)) {
+          return payload;
+        }
+        return parseLineDirectives(payload);
+      },
+      targetResolver: {
+        looksLikeId: (id) => {
+          const trimmed = id?.trim();
+          if (!trimmed) {
+            return false;
+          }
+          return /^[UCR][a-f0-9]{32}$/i.test(trimmed) || /^line:/i.test(trimmed);
+        },
+        hint: "<userId|groupId|roomId>",
+      },
+    },
+    directory: createEmptyChannelDirectoryAdapter(),
+    setup: lineSetupAdapter,
+    status: lineStatusAdapter,
+    gateway: lineGatewayAdapter,
+    bindings: lineBindingsAdapter,
+    conversationBindings: {
+      defaultTopLevelPlacement: "current",
+    },
+    agentPrompt: {
+      messageToolHints: () => [
+        "",
+        "### LINE Rich Messages",
+        "LINE supports rich visual messages. Use these directives in your reply when appropriate:",
+        "",
+        "**Quick Replies** (bottom button suggestions):",
+        "  [[quick_replies: Option 1, Option 2, Option 3]]",
+        "",
+        "**Location** (map pin):",
+        "  [[location: Place Name | Address | latitude | longitude]]",
+        "",
+        "**Confirm Dialog** (yes/no prompt):",
+        "  [[confirm: Question text? | Yes Label | No Label]]",
+        "",
+        "**Button Menu** (title + text + buttons):",
+        "  [[buttons: Title | Description | Btn1:action1, Btn2:https://url.com]]",
+        "",
+        "**Media Player Card** (music status):",
+        "  [[media_player: Song Title | Artist Name | Source | https://albumart.url | playing]]",
+        "  - Status: 'playing' or 'paused' (optional)",
+        "",
+        "**Event Card** (calendar events, meetings):",
+        "  [[event: Event Title | Date | Time | Location | Description]]",
+        "  - Time, Location, Description are optional",
+        "",
+        "**Agenda Card** (multiple events/schedule):",
+        "  [[agenda: Schedule Title | Event1:9:00 AM, Event2:12:00 PM, Event3:3:00 PM]]",
+        "",
+        "**Device Control Card** (smart devices, TVs, etc.):",
+        "  [[device: Device Name | Device Type | Status | Control1:data1, Control2:data2]]",
+        "",
+        "**Apple TV Remote** (full D-pad + transport):",
+        "  [[appletv_remote: Apple TV | Playing]]",
+        "",
+        "**Auto-converted**: Markdown tables become Flex cards, code blocks become styled cards.",
+        "",
+        "When to use rich messages:",
+        "- Use [[quick_replies:...]] when offering 2-4 clear options",
+        "- Use [[confirm:...]] for yes/no decisions",
+        "- Use [[buttons:...]] for menus with actions/links",
+        "- Use [[location:...]] when sharing a place",
+        "- Use [[media_player:...]] when showing what's playing",
+        "- Use [[event:...]] for calendar event details",
+        "- Use [[agenda:...]] for a day's schedule or event list",
+        "- Use [[device:...]] for smart device status/controls",
+        "- Tables/code in your response auto-convert to visual cards",
+      ],
+    },
+  },
+  pairing: {
+    text: {
+      idLabel: "lineUserId",
+      message: "OpenClaw: your access has been approved.",
+      normalizeAllowEntry: createPairingPrefixStripper(/^line:(?:user:)?/i),
+      notify: async ({ cfg, id, message }) => {
+        const account = (getLineRuntime().channel.line?.resolveLineAccount ?? resolveLineAccount)({
+          cfg,
+        });
+        if (!account.channelAccessToken) {
+          throw new Error("LINE channel access token not configured");
+        }
+        const pushMessageLine =
+          getLineRuntime().channel.line?.pushMessageLine ??
+          (await loadLineChannelRuntime()).pushMessageLine;
+        await pushMessageLine(id, message, {
+          cfg,
+          accountId: account.accountId,
+          channelAccessToken: account.channelAccessToken,
+        });
+      },
+    },
+  },
+  security: lineSecurityAdapter,
+  outbound: lineOutboundAdapter,
+});

package/src/config-adapter.ts

@@ -0,0 +1,29 @@
+import { createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import {
+  listLineAccountIds,
+  resolveDefaultLineAccountId,
+  resolveLineAccount,
+  type ResolvedLineAccount,
+} from "./channel-api.js";
+
+function normalizeLineAllowFrom(entry: string): string {
+  return entry.replace(/^line:(?:user:)?/i, "");
+}
+
+export const lineConfigAdapter = createScopedChannelConfigAdapter<
+  ResolvedLineAccount,
+  ResolvedLineAccount
+>({
+  sectionKey: "line",
+  listAccountIds: listLineAccountIds,
+  resolveAccount: (cfg, accountId) =>
+    resolveLineAccount({ cfg, accountId: accountId ?? undefined }),
+  defaultAccountId: resolveDefaultLineAccountId,
+  clearBaseFields: ["channelSecret", "tokenFile", "secretFile"],
+  resolveAllowFrom: (account) => account.config.allowFrom,
+  formatAllowFrom: (allowFrom) =>
+    allowFrom
+      .map((entry) => String(entry).trim())
+      .filter(Boolean)
+      .map(normalizeLineAllowFrom),
+});

package/src/config-schema.ts

@@ -0,0 +1,57 @@
+import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
+import { z } from "openclaw/plugin-sdk/zod";
+
+const DmPolicySchema = z.enum(["open", "allowlist", "pairing", "disabled"]);
+const GroupPolicySchema = z.enum(["open", "allowlist", "disabled"]);
+const ThreadBindingsSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    idleHours: z.number().optional(),
+    maxAgeHours: z.number().optional(),
+    spawnSessions: z.boolean().optional(),
+    defaultSpawnContext: z.enum(["isolated", "fork"]).optional(),
+    spawnSubagentSessions: z.boolean().optional(),
+    spawnAcpSessions: z.boolean().optional(),
+  })
+  .strict();
+
+const LineCommonConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  channelAccessToken: z.string().optional(),
+  channelSecret: z.string().optional(),
+  tokenFile: z.string().optional(),
+  secretFile: z.string().optional(),
+  name: z.string().optional(),
+  allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  dmPolicy: DmPolicySchema.optional().default("pairing"),
+  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  responsePrefix: z.string().optional(),
+  mediaMaxMb: z.number().optional(),
+  webhookPath: z.string().optional(),
+  threadBindings: ThreadBindingsSchema.optional(),
+});
+
+const LineGroupConfigSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    requireMention: z.boolean().optional(),
+    systemPrompt: z.string().optional(),
+    skills: z.array(z.string()).optional(),
+  })
+  .strict();
+
+const LineAccountConfigSchema = LineCommonConfigSchema.extend({
+  groups: z.record(z.string(), LineGroupConfigSchema.optional()).optional(),
+}).strict();
+
+export const LineConfigSchema = LineCommonConfigSchema.extend({
+  accounts: z.record(z.string(), LineAccountConfigSchema.optional()).optional(),
+  defaultAccount: z.string().optional(),
+  groups: z.record(z.string(), LineGroupConfigSchema.optional()).optional(),
+}).strict();
+
+export const LineChannelConfigSchema = buildChannelConfigSchema(LineConfigSchema);
+
+export type LineConfigSchemaType = z.infer<typeof LineConfigSchema>;

package/src/download.test.ts

@@ -0,0 +1,133 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+const getMessageContentMock = vi.hoisted(() => vi.fn());
+const saveMediaBufferMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@line/bot-sdk", () => ({
+  messagingApi: {
+    MessagingApiBlobClient: class {
+      getMessageContent(messageId: string) {
+        return getMessageContentMock(messageId);
+      }
+    },
+  },
+}));
+
+vi.mock("openclaw/plugin-sdk/runtime-env", () => ({
+  createSubsystemLogger: () => {
+    const logger = {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      child: () => logger,
+    };
+    return logger;
+  },
+  logVerbose: () => {},
+}));
+
+vi.mock("openclaw/plugin-sdk/media-store", () => ({
+  saveMediaBuffer: saveMediaBufferMock,
+}));
+
+let downloadLineMedia: typeof import("./download.js").downloadLineMedia;
+
+async function* chunks(parts: Buffer[]): AsyncGenerator<Buffer> {
+  for (const part of parts) {
+    yield part;
+  }
+}
+
+describe("downloadLineMedia", () => {
+  beforeAll(async () => {
+    ({ downloadLineMedia } = await import("./download.js"));
+  });
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    getMessageContentMock.mockReset();
+    saveMediaBufferMock.mockReset();
+    saveMediaBufferMock.mockImplementation(
+      async (_buffer: Buffer, contentType?: string, subdir?: string) => ({
+        path: `/home/user/.openclaw/media/${subdir ?? "unknown"}/saved-media`,
+        contentType,
+      }),
+    );
+  });
+
+  it("persists inbound media with the shared media store", async () => {
+    const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0x00]);
+    getMessageContentMock.mockResolvedValueOnce(chunks([jpeg]));
+
+    const result = await downloadLineMedia("mid-jpeg", "token");
+
+    expect(saveMediaBufferMock).toHaveBeenCalledTimes(1);
+    const call = saveMediaBufferMock.mock.calls[0];
+    expect((call?.[0] as Buffer).equals(jpeg)).toBe(true);
+    expect(call?.[1]).toBe("image/jpeg");
+    expect(call?.[2]).toBe("inbound");
+    expect(call?.[3]).toBe(10 * 1024 * 1024);
+    expect(result).toEqual({
+      path: "/home/user/.openclaw/media/inbound/saved-media",
+      contentType: "image/jpeg",
+      size: jpeg.length,
+    });
+  });
+
+  it("does not pass the external messageId to saveMediaBuffer", async () => {
+    const messageId = "a/../../../../etc/passwd";
+    const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0x00]);
+    getMessageContentMock.mockResolvedValueOnce(chunks([jpeg]));
+
+    const result = await downloadLineMedia(messageId, "token");
+
+    expect(result.size).toBe(jpeg.length);
+    expect(result.contentType).toBe("image/jpeg");
+    for (const arg of saveMediaBufferMock.mock.calls[0] ?? []) {
+      if (typeof arg === "string") {
+        expect(arg).not.toContain(messageId);
+      }
+    }
+  });
+
+  it("rejects oversized media before invoking saveMediaBuffer", async () => {
+    getMessageContentMock.mockResolvedValueOnce(chunks([Buffer.alloc(4), Buffer.alloc(4)]));
+
+    await expect(downloadLineMedia("mid", "token", 7)).rejects.toThrow(/Media exceeds/i);
+    expect(saveMediaBufferMock).not.toHaveBeenCalled();
+  });
+
+  it("classifies M4A ftyp major brand as audio/mp4", async () => {
+    const m4aHeader = Buffer.from([
+      0x00, 0x00, 0x00, 0x1c, 0x66, 0x74, 0x79, 0x70, 0x4d, 0x34, 0x41, 0x20,
+    ]);
+    getMessageContentMock.mockResolvedValueOnce(chunks([m4aHeader]));
+
+    const result = await downloadLineMedia("mid-audio", "token");
+
+    expect(result.contentType).toBe("audio/mp4");
+    expect(saveMediaBufferMock.mock.calls[0]?.[1]).toBe("audio/mp4");
+    expect(saveMediaBufferMock.mock.calls[0]?.[2]).toBe("inbound");
+  });
+
+  it("detects MP4 video from ftyp major brand (isom)", async () => {
+    const mp4 = Buffer.from([
+      0x00, 0x00, 0x00, 0x1c, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6f, 0x6d,
+    ]);
+    getMessageContentMock.mockResolvedValueOnce(chunks([mp4]));
+
+    const result = await downloadLineMedia("mid-mp4", "token");
+
+    expect(result.contentType).toBe("video/mp4");
+    expect(saveMediaBufferMock.mock.calls[0]?.[1]).toBe("video/mp4");
+  });
+
+  it("propagates media store failures", async () => {
+    const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0x00]);
+    getMessageContentMock.mockResolvedValueOnce(chunks([jpeg]));
+    saveMediaBufferMock.mockRejectedValueOnce(new Error("Media exceeds 0MB limit"));
+
+    await expect(downloadLineMedia("mid-bad", "token")).rejects.toThrow(/Media exceeds/i);
+  });
+});

package/src/download.ts

@@ -0,0 +1,87 @@
+import { messagingApi } from "@line/bot-sdk";
+import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { lowercasePreservingWhitespace } from "openclaw/plugin-sdk/text-runtime";
+
+interface DownloadResult {
+  path: string;
+  contentType?: string;
+  size: number;
+}
+
+const AUDIO_BRANDS = new Set(["m4a ", "m4b ", "m4p ", "m4r ", "f4a ", "f4b "]);
+
+export async function downloadLineMedia(
+  messageId: string,
+  channelAccessToken: string,
+  maxBytes = 10 * 1024 * 1024,
+): Promise<DownloadResult> {
+  const client = new messagingApi.MessagingApiBlobClient({
+    channelAccessToken,
+  });
+
+  const response = await client.getMessageContent(messageId);
+  const chunks: Buffer[] = [];
+  let totalSize = 0;
+
+  for await (const chunk of response as AsyncIterable<Buffer>) {
+    totalSize += chunk.length;
+    if (totalSize > maxBytes) {
+      throw new Error(`Media exceeds ${Math.round(maxBytes / (1024 * 1024))}MB limit`);
+    }
+    chunks.push(chunk);
+  }
+
+  const buffer = Buffer.concat(chunks);
+  const contentType = detectContentType(buffer);
+  const saved = await saveMediaBuffer(buffer, contentType, "inbound", maxBytes);
+  logVerbose(`line: persisted media ${messageId} to ${saved.path} (${buffer.length} bytes)`);
+
+  return {
+    path: saved.path,
+    contentType: saved.contentType,
+    size: buffer.length,
+  };
+}
+
+function detectContentType(buffer: Buffer): string {
+  const hasFtypBox =
+    buffer.length >= 12 &&
+    buffer[4] === 0x66 &&
+    buffer[5] === 0x74 &&
+    buffer[6] === 0x79 &&
+    buffer[7] === 0x70;
+
+  if (buffer.length >= 2) {
+    if (buffer[0] === 0xff && buffer[1] === 0xd8) {
+      return "image/jpeg";
+    }
+    if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47) {
+      return "image/png";
+    }
+    if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) {
+      return "image/gif";
+    }
+    if (
+      buffer[0] === 0x52 &&
+      buffer[1] === 0x49 &&
+      buffer[2] === 0x46 &&
+      buffer[3] === 0x46 &&
+      buffer[8] === 0x57 &&
+      buffer[9] === 0x45 &&
+      buffer[10] === 0x42 &&
+      buffer[11] === 0x50
+    ) {
+      return "image/webp";
+    }
+    if (hasFtypBox) {
+      const majorBrand = lowercasePreservingWhitespace(buffer.toString("ascii", 8, 12));
+      if (AUDIO_BRANDS.has(majorBrand)) {
+        return "audio/mp4";
+      }
+      return "video/mp4";
+    }
+  }
+
+  return "application/octet-stream";
+}