@zeyiy/openclaw-channel 0.3.5 → 0.3.7

package/dist/tools.js

@@ -1,130 +1,171 @@
 import { getConnectedClient } from "./clients";
+import { fetchGroupInfo, fetchGroupMembers } from "./inbound";
 import { sendFileToTarget, sendImageToTarget, sendTextToTarget, sendVideoToTarget } from "./media";
 import { parseTarget } from "./targets";
 import { formatSdkError } from "./utils";
+function err(msg) {
+    return { content: [{ type: "text", text: msg }] };
+}
+function ok(msg) {
+    return { content: [{ type: "text", text: msg }] };
+}
 export function registerOpenIMTools(api) {
     if (typeof api.registerTool !== "function")
         return;
-    const ensureTargetAndClient = (params) => {
-        const target = parseTarget(params.target);
-        if (!target) {
-            return {
-                ok: false,
-                result: {
-                    content: [{ type: "text", text: "Invalid target format. Expected user:<id> or group:<id>." }],
-                },
-            };
-        }
-        const client = getConnectedClient(params.accountId);
-        if (!client) {
-            return {
-                ok: false,
-                result: {
-                    content: [{ type: "text", text: "OpenIM is not connected." }],
-                },
-            };
-        }
-        return { ok: true, target, client };
-    };
-    api.registerTool({
-        name: "openim_send_text",
-        description: "Send a text message via OpenIM. target format: user:ID or group:ID.",
-        parameters: {
-            type: "object",
-            properties: {
-                target: { type: "string", description: "user:123 or group:456" },
-                text: { type: "string", description: "Text to send" },
-                accountId: { type: "string", description: "Optional account ID. Defaults to `default` or the first connected account." },
-            },
-            required: ["target", "text"],
-        },
-        async execute(_id, params) {
-            const checked = ensureTargetAndClient(params);
-            if (!checked.ok)
-                return checked.result;
-            try {
-                await sendTextToTarget(checked.client, checked.target, params.text);
-                return { content: [{ type: "text", text: "Sent successfully" }] };
-            }
-            catch (e) {
-                return { content: [{ type: "text", text: `Send failed: ${formatSdkError(e)}` }] };
-            }
-        },
-    });
     api.registerTool({
-        name: "openim_send_image",
-        description: "Send an image via OpenIM. `image` supports a local path or an http(s) URL.",
+        name: "openim_management",
+        label: "OpenIM Management",
+        description: "Unified tool for OpenIM operations: send messages (text/image/video/file), " +
+            "query group info, and list group members. Use this tool for all OpenIM interactions.",
         parameters: {
             type: "object",
             properties: {
-                target: { type: "string", description: "user:123 or group:456" },
-                image: { type: "string", description: "Local path (`file://` supported) or URL" },
-                accountId: { type: "string", description: "Optional account ID" },
-            },
-            required: ["target", "image"],
-        },
-        async execute(_id, params) {
-            const checked = ensureTargetAndClient(params);
-            if (!checked.ok)
-                return checked.result;
-            try {
-                await sendImageToTarget(checked.client, checked.target, params.image);
-                return { content: [{ type: "text", text: "Image sent successfully" }] };
-            }
-            catch (e) {
-                return { content: [{ type: "text", text: `Send failed: ${formatSdkError(e)}` }] };
-            }
-        },
-    });
-    api.registerTool({
-        name: "openim_send_video",
-        description: "Send a video via OpenIM (delivered as a file message). `video` supports a local path or URL.",
-        parameters: {
-            type: "object",
-            properties: {
-                target: { type: "string", description: "user:123 or group:456" },
-                video: { type: "string", description: "Local path (`file://` supported) or URL" },
-                name: { type: "string", description: "Optional filename (recommended for URL input)" },
-                accountId: { type: "string", description: "Optional account ID" },
-            },
-            required: ["target", "video"],
-        },
-        async execute(_id, params) {
-            const checked = ensureTargetAndClient(params);
-            if (!checked.ok)
-                return checked.result;
-            try {
-                await sendVideoToTarget(checked.client, checked.target, params.video, params.name);
-                return { content: [{ type: "text", text: "Video sent successfully as a file" }] };
-            }
-            catch (e) {
-                return { content: [{ type: "text", text: `Send failed: ${formatSdkError(e)}` }] };
-            }
-        },
-    });
-    api.registerTool({
-        name: "openim_send_file",
-        description: "Send a file via OpenIM. `file` supports a local path or URL; `name` is optional.",
-        parameters: {
-            type: "object",
-            properties: {
-                target: { type: "string", description: "user:123 or group:456" },
-                file: { type: "string", description: "Local path (`file://` supported) or URL" },
-                name: { type: "string", description: "Optional filename (recommended for URL input)" },
-                accountId: { type: "string", description: "Optional account ID" },
+                action: {
+                    type: "string",
+                    enum: [
+                        "send-text",
+                        "send-image",
+                        "send-video",
+                        "send-file",
+                        "group-info",
+                        "group-members",
+                    ],
+                    description: "The action to perform.",
+                },
+                target: {
+                    type: "string",
+                    description: "Target for send actions. Format: user:<id> or group:<id>.",
+                },
+                text: {
+                    type: "string",
+                    description: "Text content. Required for send-text.",
+                },
+                image: {
+                    type: "string",
+                    description: "Image local path or URL. Required for send-image.",
+                },
+                video: {
+                    type: "string",
+                    description: "Video local path or URL. Required for send-video.",
+                },
+                file: {
+                    type: "string",
+                    description: "File local path or URL. Required for send-file.",
+                },
+                name: {
+                    type: "string",
+                    description: "Optional filename for send-video / send-file.",
+                },
+                groupID: {
+                    type: "string",
+                    description: "Group ID. Required for group-info and group-members.",
+                },
+                accountId: {
+                    type: "string",
+                    description: "Optional OpenIM account ID. Defaults to the first connected account.",
+                },
             },
-            required: ["target", "file"],
+            required: ["action"],
         },
         async execute(_id, params) {
-            const checked = ensureTargetAndClient(params);
-            if (!checked.ok)
-                return checked.result;
-            try {
-                await sendFileToTarget(checked.client, checked.target, params.file, params.name);
-                return { content: [{ type: "text", text: "File sent successfully" }] };
-            }
-            catch (e) {
-                return { content: [{ type: "text", text: `Send failed: ${formatSdkError(e)}` }] };
+            const client = getConnectedClient(params.accountId);
+            if (!client)
+                return err("OpenIM is not connected.");
+            switch (params.action) {
+                // ── Send actions ────────────────────────────────────────────
+                case "send-text": {
+                    if (!params.target || !params.text)
+                        return err("Missing required: target, text");
+                    const target = parseTarget(params.target);
+                    if (!target)
+                        return err("Invalid target format. Expected user:<id> or group:<id>.");
+                    try {
+                        await sendTextToTarget(client, target, params.text);
+                        return ok("Sent successfully");
+                    }
+                    catch (e) {
+                        return err(`Send failed: ${formatSdkError(e)}`);
+                    }
+                }
+                case "send-image": {
+                    if (!params.target || !params.image)
+                        return err("Missing required: target, image");
+                    const target = parseTarget(params.target);
+                    if (!target)
+                        return err("Invalid target format. Expected user:<id> or group:<id>.");
+                    try {
+                        await sendImageToTarget(client, target, params.image);
+                        return ok("Image sent successfully");
+                    }
+                    catch (e) {
+                        return err(`Send failed: ${formatSdkError(e)}`);
+                    }
+                }
+                case "send-video": {
+                    if (!params.target || !params.video)
+                        return err("Missing required: target, video");
+                    const target = parseTarget(params.target);
+                    if (!target)
+                        return err("Invalid target format. Expected user:<id> or group:<id>.");
+                    try {
+                        await sendVideoToTarget(client, target, params.video, params.name);
+                        return ok("Video sent successfully");
+                    }
+                    catch (e) {
+                        return err(`Send failed: ${formatSdkError(e)}`);
+                    }
+                }
+                case "send-file": {
+                    if (!params.target || !params.file)
+                        return err("Missing required: target, file");
+                    const target = parseTarget(params.target);
+                    if (!target)
+                        return err("Invalid target format. Expected user:<id> or group:<id>.");
+                    try {
+                        await sendFileToTarget(client, target, params.file, params.name);
+                        return ok("File sent successfully");
+                    }
+                    catch (e) {
+                        return err(`Send failed: ${formatSdkError(e)}`);
+                    }
+                }
+                // ── Group query actions ─────────────────────────────────────
+                case "group-info": {
+                    if (!params.groupID)
+                        return err("Missing required: groupID");
+                    try {
+                        const info = await fetchGroupInfo(client, params.groupID, undefined, true);
+                        if (!info)
+                            return err("Group not found or fetch failed.");
+                        const parts = [
+                            `Group: ${info.groupName}`,
+                            `Members: ${info.memberCount}`,
+                            info.notification ? `Announcement: ${info.notification}` : null,
+                            info.introduction ? `Introduction: ${info.introduction}` : null,
+                        ].filter(Boolean);
+                        return ok(parts.join("\n"));
+                    }
+                    catch (e) {
+                        return err(`Failed: ${formatSdkError(e)}`);
+                    }
+                }
+                case "group-members": {
+                    if (!params.groupID)
+                        return err("Missing required: groupID");
+                    try {
+                        const data = await fetchGroupMembers(client, params.groupID, undefined, true);
+                        if (!data || data.uidToName.size === 0)
+                            return err("No members found or fetch failed.");
+                        const lines = Array.from(data.uidToName.entries())
+                            .map(([uid, name]) => `${name} (${uid})`);
+                        return ok(`Group members (${lines.length}):\n${lines.join("\n")}`);
+                    }
+                    catch (e) {
+                        return err(`Failed: ${formatSdkError(e)}`);
+                    }
+                }
+                default:
+                    return err(`Unknown action: ${params.action}`);
             }
         },
     });

package/dist/types.d.ts

@@ -10,9 +10,27 @@ export interface OpenIMAccountConfig {
     platformID: number;
     requireMention: boolean;
     inboundWhitelist: string[];
+    historyLimit: number;
     botId?: string;
     portalWsAddr?: string;
 }
+export interface GroupInfoCacheEntry {
+    groupName: string;
+    notification: string;
+    introduction: string;
+    memberCount: number;
+    fetchedAt: number;
+}
+export interface GroupMemberCacheEntry {
+    uidToName: Map<string, string>;
+    fetchedAt: number;
+}
+export interface HistoryEntry {
+    sender: string;
+    senderName: string;
+    body: string;
+    timestamp: number;
+}
 export interface OpenIMClientState {
     sdk: ApiService;
     config: OpenIMAccountConfig;
@@ -39,7 +57,51 @@ export interface InboundBodyResult {
     kind: "text" | "image" | "video" | "file" | "mixed" | "unknown";
     media?: InboundMediaItem[];
 }
-export type PortalMethod = "bot.agent.get" | "models.list" | "agents.list" | "agents.files.list" | "agents.files.get" | "agents.files.set" | "agents.create" | "ping";
+export type PortalMethod = "bot.agent.get" | "models.list" | "agents.list" | "agents.files.list" | "agents.files.get" | "agents.files.set" | "agents.create" | "agent.skills.status" | "agent.skills.set" | "agent.model.set" | "tools.catalog" | "skills.status" | "skills.search" | "skills.set" | "skills.install" | "cron.list" | "ping";
+export type CronJobSchedule = {
+    kind: "at";
+    at: string;
+} | {
+    kind: "every";
+    everyMs: number;
+    anchorMs?: number;
+} | {
+    kind: "cron";
+    expr: string;
+    tz?: string;
+    staggerMs?: number;
+};
+export type CronJobState = {
+    nextRunAtMs?: number;
+    runningAtMs?: number;
+    lastRunAtMs?: number;
+    lastRunStatus?: "ok" | "error" | "skipped";
+    lastError?: string;
+    lastDurationMs?: number;
+    consecutiveErrors?: number;
+    lastDelivered?: boolean;
+    lastDeliveryStatus?: "delivered" | "not-delivered" | "unknown" | "not-requested";
+    lastDeliveryError?: string;
+    lastFailureAlertAtMs?: number;
+};
+export interface CronJobEntry {
+    id: string;
+    name: string;
+    description?: string;
+    agentId?: string;
+    sessionKey?: string;
+    enabled: boolean;
+    deleteAfterRun?: boolean;
+    createdAtMs: number;
+    updatedAtMs: number;
+    schedule: CronJobSchedule;
+    sessionTarget: string;
+    wakeMode: "next-heartbeat" | "now";
+    payload: Record<string, unknown>;
+    delivery?: Record<string, unknown>;
+    failureAlert?: false | Record<string, unknown>;
+    state: CronJobState;
+}
 export interface PortalRequest {
     id: string;
     method: PortalMethod;

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-channel",
   "name": "OpenIM Channel",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "OpenIM protocol channel for OpenClaw",
   "author": "ZeyiY",
   "channels": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeyiy/openclaw-channel",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "OpenIM channel plugin for OpenClaw gateway (fork of @openim/openclaw-channel)",
   "license": "AGPL-3.0-only",
   "author": "ZeyiY",