kece-skill-mcp 0.0.0-stage → 1.1.0

package/dist/auth.d.ts

@@ -0,0 +1,5 @@
+import type { Config } from "./config.js";
+export declare function md5(content: string): string;
+export declare function aesEncrypt(plainText: string, appSecret: string): string;
+export type AuthHeaders = Record<string, string>;
+export declare function buildAuthHeaders(body: string, config: Config): AuthHeaders;

package/dist/auth.js

@@ -0,0 +1,27 @@
+import { createHash, createCipheriv } from "crypto";
+export function md5(content) {
+    return createHash("md5").update(content, "utf-8").digest("hex");
+}
+function deriveAesKey(appSecret) {
+    const sha1Pass1 = createHash("sha1").update(appSecret, "utf-8").digest();
+    const sha1Pass2 = createHash("sha1").update(sha1Pass1).digest();
+    return sha1Pass2.subarray(0, 16);
+}
+export function aesEncrypt(plainText, appSecret) {
+    const keyBuffer = deriveAesKey(appSecret);
+    const cipher = createCipheriv("aes-128-ecb", keyBuffer, null);
+    cipher.setAutoPadding(true);
+    return cipher.update(plainText, "utf-8", "hex") + cipher.final("hex");
+}
+export function buildAuthHeaders(body, config) {
+    const sign = md5(body);
+    const curtime = Math.floor(Date.now() / 1000).toString();
+    const checksum = aesEncrypt(config.appKey + sign + curtime, config.appSecret);
+    return {
+        "ur-appkey": config.appKey,
+        "ur-sign": sign,
+        "ur-curtime": curtime,
+        "ur-checksum": checksum,
+        "Content-Type": "application/json;charset=utf-8",
+    };
+}

package/dist/client.d.ts

@@ -0,0 +1,6 @@
+import type { Config } from "./config.js";
+export declare class KeceClient {
+    private config;
+    constructor(config: Config);
+    request<T = any>(path: string, body: Record<string, any>): Promise<T>;
+}

package/dist/client.js

@@ -0,0 +1,25 @@
+import { buildAuthHeaders } from "./auth.js";
+export class KeceClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async request(path, body) {
+        const bodyStr = JSON.stringify(body);
+        const headers = buildAuthHeaders(bodyStr, this.config);
+        const url = `${this.config.baseUrl}${path}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: bodyStr,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+        }
+        const result = await response.json();
+        if (result.code && String(result.code) !== "200") {
+            throw new Error(`API错误 [${result.code}]: ${result.msg || "未知错误"}`);
+        }
+        return result;
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+export interface Config {
+    appKey: string;
+    appSecret: string;
+    baseUrl: string;
+}
+export declare function getConfig(): Config;

package/dist/config.js

@@ -0,0 +1,30 @@
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function loadEnv() {
+    const envVars = {};
+    try {
+        const envPath = resolve(import.meta.dirname, "../.env");
+        const content = readFileSync(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx === -1)
+                continue;
+            envVars[trimmed.slice(0, eqIdx)] = trimmed.slice(eqIdx + 1);
+        }
+    }
+    catch { }
+    return envVars;
+}
+export function getConfig() {
+    const env = { ...loadEnv(), ...process.env };
+    const appKey = env.KECE_APP_KEY;
+    const appSecret = env.KECE_APP_SECRET;
+    const baseUrl = env.KECE_BASE_URL || "https://huke.163.com";
+    if (!appKey || !appSecret) {
+        throw new Error("缺少 KECE_APP_KEY 或 KECE_APP_SECRET 配置");
+    }
+    return { appKey, appSecret, baseUrl };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { getConfig } from "./config.js";
+import { KeceClient } from "./client.js";
+import { queryCustomerSchema, queryCustomer } from "./tools/customer-query.js";
+import { searchCustomersSchema, searchCustomers } from "./tools/customer-search.js";
+import { updateCustomerTagSchema, updateCustomerTag, batchUpdateTagSchema, batchUpdateCustomerTag } from "./tools/customer-tag.js";
+import { createMassSendSchema, createMassSend } from "./tools/mass-send.js";
+import { getCustomerFieldsSchema, getCustomerFields, listStaffSchema, listStaff, listSegmentsSchema, listSegments, createSegmentSchema, createSegment, importSegmentSchema, importSegment, listMassSendTasksSchema, listMassSendTasks, } from "./tools/helpers.js";
+import { resolveIdsSchema, resolveIds } from "./tools/resolve-ids.js";
+let client;
+try {
+    client = new KeceClient(getConfig());
+}
+catch (err) {
+    console.error(`[kece-skill-mcp] 启动失败：${err?.message || err}`);
+    console.error("[kece-skill-mcp] 请在 WorkBuddy 连接器设置中填写 AppKey 与 AppSecret。");
+    process.exit(1);
+}
+const server = new McpServer({
+    name: "kece-scrm-skill",
+    version: "1.1.0",
+});
+function safeTool(fn) {
+    return async (params) => {
+        try {
+            const result = await fn(params);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            const msg = err?.message || String(err);
+            let hint = "";
+            if (msg.includes("1014") || msg.includes("认证失败")) {
+                hint = "\n\n请检查 AppKey 和 AppSecret 是否正确。获取路径：科策后台 → 设置 → 系统对接 → API对接";
+            }
+            else if (msg.includes("1003") || msg.includes("无权限")) {
+                hint = "\n\n当前 API 账号无此操作权限，请联系管理员。";
+            }
+            else if (msg.includes("1009") || msg.includes("缺少参数")) {
+                hint = "\n\n请补充必要参数后重试。";
+            }
+            else if (msg.includes("fetch") || msg.includes("ECONNREFUSED") || msg.includes("ETIMEDOUT")) {
+                hint = "\n\n无法连接科策服务器，请检查网络或稍后重试。";
+            }
+            return { content: [{ type: "text", text: `调用失败：${msg}${hint}` }] };
+        }
+    };
+}
+// ===== Skill 1: 查客户 =====
+server.tool("query_customer", "查询客户详情。支持通过手机号、姓名、微信号、邮箱、CID、公司名称查询客户信息。", queryCustomerSchema.shape, safeTool((params) => queryCustomer(client, params)));
+// ===== Skill 3: 圈人 =====
+server.tool("search_customers", "条件筛选客户（圈人）。支持按标签、手机号、客层等条件筛选客户，返回符合条件的客户列表和总数。用于人群圈选。", searchCustomersSchema.shape, safeTool((params) => searchCustomers(client, params)));
+// ===== Skill 2: 打标签 =====
+server.tool("update_customer_tag", "为单个客户添加或移除标签。需要先通过 get_customer_fields 获取标签组ID和标签ID。", updateCustomerTagSchema.shape, safeTool((params) => updateCustomerTag(client, params)));
+server.tool("batch_update_tag", "批量为多个客户添加或移除标签。传入客户ID列表，并发执行。超过10人时建议先确认。", batchUpdateTagSchema.shape, safeTool((params) => batchUpdateCustomerTag(client, params)));
+// ===== Skill 4: 群发 =====
+server.tool("create_mass_send", "创建企微客户群发任务。基于筛选条件圈选目标客户并发送消息。所有群发操作必须经用户确认后执行。", createMassSendSchema.shape, safeTool((params) => createMassSend(client, params)));
+// ===== 辅助工具 =====
+server.tool("get_customer_fields", "获取所有客户字段定义，包括标签组及选项。用于将标签名称转换为标签ID，是打标签和圈人的前置查询。", getCustomerFieldsSchema.shape, safeTool(() => getCustomerFields(client)));
+server.tool("list_staff", "查询企业员工列表，返回 accid、姓名、角色、部门。用于群发时获取发送人 accid 列表。", listStaffSchema.shape, safeTool((params) => listStaff(client, params)));
+server.tool("list_segments", "查询人群包列表。支持按关键词搜索。用于查看已有人群包或获取人群包ID。", listSegmentsSchema.shape, safeTool((params) => listSegments(client, params)));
+server.tool("create_segment", "创建一个新的导入型人群包。创建后可通过 import_segment 导入用户。", createSegmentSchema.shape, safeTool((params) => createSegment(client, params)));
+server.tool("import_segment", "将客户ID列表导入到指定人群包。配合 search_customers 获取的 cid 和 create_segment 创建的人群包使用。", importSegmentSchema.shape, safeTool((params) => importSegment(client, params)));
+server.tool("list_mass_send_tasks", "查询群发任务列表，了解最近群发的执行状态。", listMassSendTasksSchema.shape, safeTool((params) => listMassSendTasks(client, params)));
+// ===== ID 映射（科策 × 数数打通） =====
+server.tool("resolve_ids", "双向转换游戏账号ID(数数#account_id)与科策客户ID(cid)。用于科策与数数ThinkingData之间的用户身份打通。需要先通过 get_customer_fields 确认存储游戏账号ID的字段。", resolveIdsSchema.shape, safeTool((params) => resolveIds(client, params)));
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch(console.error);

package/dist/tools/customer-query.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { KeceClient } from "../client.js";
+export declare const queryCustomerSchema: z.ZodObject<{
+    type: z.ZodEnum<["phone", "wechat", "email", "cid", "name", "company"]>;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "phone" | "wechat" | "email" | "cid" | "name" | "company";
+    value: string;
+}, {
+    type: "phone" | "wechat" | "email" | "cid" | "name" | "company";
+    value: string;
+}>;
+export declare function queryCustomer(client: KeceClient, params: z.infer<typeof queryCustomerSchema>): Promise<{
+    found: boolean;
+    message: string;
+    total?: undefined;
+    customers?: undefined;
+} | {
+    found: boolean;
+    total: any;
+    customers: any;
+    message?: undefined;
+}>;

package/dist/tools/customer-query.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+export const queryCustomerSchema = z.object({
+    type: z
+        .enum(["phone", "wechat", "email", "cid", "name", "company"])
+        .describe("查询类型：phone=手机号, wechat=微信号, email=邮箱, cid=客户ID, name=姓名, company=公司名称"),
+    value: z.string().describe("查询值，如手机号、姓名等"),
+});
+const TYPE_MAP = {
+    phone: 0,
+    wechat: 1,
+    email: 2,
+    cid: 3,
+    name: 5,
+    company: 6,
+};
+export async function queryCustomer(client, params) {
+    const result = await client.request("/openapi/customer/query", {
+        type: TYPE_MAP[params.type],
+        targets: [params.value],
+    });
+    const customers = result.data || [];
+    if (customers.length === 0) {
+        return { found: false, message: "未找到匹配的客户，请确认信息是否正确" };
+    }
+    const formatted = customers.map((c) => ({
+        cid: c.cid,
+        name: getFieldValue(c.customFields, -2),
+        phone: maskPhone(getFieldValue(c.customFields, -3)),
+        wechatNick: getFieldValue(c.customFields, -6),
+        email: getFieldValue(c.customFields, -4),
+        follower: c.followerNick || c.follower,
+        status: formatStatus(c.status),
+        tags: c.customFields
+            ?.filter((f) => f.type === 4 || f.type === 5 || f.type === 11)
+            .map((f) => ({ name: f.name, value: f.fieldValue })) || [],
+        createTime: formatTime(c.createTime),
+        entryTime: formatTime(c.entryTime),
+        lastActivity: formatTime(c.updateTime),
+    }));
+    return {
+        found: true,
+        total: customers.length,
+        customers: formatted,
+    };
+}
+function getFieldValue(fields, id) {
+    return fields?.find((f) => f.id === id)?.fieldValue || "";
+}
+function maskPhone(phone) {
+    if (!phone || phone.length < 7)
+        return phone || "无";
+    return phone.slice(0, 3) + "****" + phone.slice(-4);
+}
+function formatStatus(status) {
+    const map = {
+        4: "待分配潜客",
+        5: "待分配",
+        6: "跟进中",
+        7: "公海",
+        8: "跟进中潜客",
+        9: "公海潜客",
+    };
+    return map[status] || `状态${status}`;
+}
+function formatTime(ts) {
+    if (!ts)
+        return "无";
+    return new Date(ts).toISOString().slice(0, 10);
+}

package/dist/tools/customer-search.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import type { KeceClient } from "../client.js";
+export declare const searchCustomersSchema: z.ZodObject<{
+    filterType: z.ZodEnum<["quick", "advanced", "segment"]>;
+    filterFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        fieldId: z.ZodString;
+        filterType: z.ZodNumber;
+        filterValue: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        fieldId: string;
+        filterType: number;
+        filterValue?: string | undefined;
+    }, {
+        fieldId: string;
+        filterType: number;
+        filterValue?: string | undefined;
+    }>, "many">>;
+    segmentIds: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    keyword: z.ZodOptional<z.ZodString>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    filterType: "quick" | "advanced" | "segment";
+    page: number;
+    pageSize: number;
+    filterFields?: {
+        fieldId: string;
+        filterType: number;
+        filterValue?: string | undefined;
+    }[] | undefined;
+    segmentIds?: number[] | undefined;
+    keyword?: string | undefined;
+}, {
+    filterType: "quick" | "advanced" | "segment";
+    filterFields?: {
+        fieldId: string;
+        filterType: number;
+        filterValue?: string | undefined;
+    }[] | undefined;
+    segmentIds?: number[] | undefined;
+    keyword?: string | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+}>;
+export declare function searchCustomers(client: KeceClient, params: z.infer<typeof searchCustomersSchema>): Promise<{
+    total: any;
+    page: number;
+    pageSize: number;
+    customers: any;
+}>;

package/dist/tools/customer-search.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+const filterFieldSchema = z.object({
+    fieldId: z.string().describe("筛选字段ID，如 label(标签)、mobile(手机号)"),
+    filterType: z.number().describe("筛选条件：1=满足/包含, 2=不为空, 3=包含所有, 4=不包含, 5=等于, 6=不等于, 7=介于, 8=大于, 9=小于"),
+    filterValue: z.string().optional().describe("筛选值"),
+});
+export const searchCustomersSchema = z.object({
+    filterType: z
+        .enum(["quick", "advanced", "segment"])
+        .describe("筛选模式：quick=快捷筛选(标签), advanced=高级筛选(多条件), segment=客层筛选"),
+    filterFields: z
+        .array(filterFieldSchema)
+        .optional()
+        .describe("筛选字段列表（quick/advanced 模式使用）"),
+    segmentIds: z
+        .array(z.number())
+        .optional()
+        .describe("客层ID列表（segment 模式使用）"),
+    keyword: z.string().optional().describe("搜索关键词（至少2个字符）"),
+    page: z.number().optional().default(1).describe("页码"),
+    pageSize: z.number().optional().default(50).describe("每页数量，1~200"),
+});
+const FILTER_TYPE_MAP = {
+    quick: 1,
+    advanced: 3,
+    segment: 2,
+};
+export async function searchCustomers(client, params) {
+    const body = {
+        customerType: 1,
+        page: params.page,
+        pageSize: params.pageSize,
+    };
+    if (params.keyword) {
+        body.keyword = params.keyword;
+        body.filterId = "-1";
+        body.queryFromType = 2;
+    }
+    else {
+        const queryFilter = { type: FILTER_TYPE_MAP[params.filterType] };
+        if (params.filterType === "segment") {
+            queryFilter.segmentIds = params.segmentIds || [];
+        }
+        else {
+            queryFilter.filterContent = {
+                filterFields: (params.filterFields || []).map((f) => ({
+                    fieldId: f.fieldId,
+                    filterType: f.filterType,
+                    filterValue: f.filterValue || "",
+                })),
+            };
+        }
+        body.queryFilter = queryFilter;
+    }
+    const result = await client.request("/openapi/customer/search", body);
+    return {
+        total: result.total || 0,
+        page: params.page,
+        pageSize: params.pageSize,
+        customers: (result.customerList || []).map((c) => ({
+            cid: c.cid,
+            name: c.name,
+            phone: maskPhone(c.mobile),
+            follower: c.follower,
+            labels: c.labels || [],
+            createTime: c.createTime ? new Date(c.createTime).toISOString().slice(0, 10) : "",
+            entryTime: c.entryTime ? new Date(c.entryTime).toISOString().slice(0, 10) : "",
+        })),
+    };
+}
+function maskPhone(phone) {
+    if (!phone || phone.length < 7)
+        return phone || "无";
+    return phone.slice(0, 3) + "****" + phone.slice(-4);
+}

package/dist/tools/customer-tag.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import type { KeceClient } from "../client.js";
+export declare const updateCustomerTagSchema: z.ZodObject<{
+    cid: z.ZodOptional<z.ZodNumber>;
+    externalUserid: z.ZodOptional<z.ZodString>;
+    tagGroupId: z.ZodNumber;
+    addTag: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    removeTag: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    syncQiWei: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    tagGroupId: number;
+    syncQiWei: boolean;
+    cid?: number | undefined;
+    externalUserid?: string | undefined;
+    addTag?: number[] | undefined;
+    removeTag?: number[] | undefined;
+}, {
+    tagGroupId: number;
+    cid?: number | undefined;
+    externalUserid?: string | undefined;
+    addTag?: number[] | undefined;
+    removeTag?: number[] | undefined;
+    syncQiWei?: boolean | undefined;
+}>;
+export declare function updateCustomerTag(client: KeceClient, params: z.infer<typeof updateCustomerTagSchema>): Promise<{
+    success: boolean;
+    message: string;
+    syncQiWei?: undefined;
+} | {
+    success: boolean;
+    message: string;
+    syncQiWei: boolean;
+}>;
+export declare const batchUpdateTagSchema: z.ZodObject<{
+    cidList: z.ZodArray<z.ZodNumber, "many">;
+    tagGroupId: z.ZodNumber;
+    addTag: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    removeTag: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    syncQiWei: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    tagGroupId: number;
+    syncQiWei: boolean;
+    cidList: number[];
+    addTag?: number[] | undefined;
+    removeTag?: number[] | undefined;
+}, {
+    tagGroupId: number;
+    cidList: number[];
+    addTag?: number[] | undefined;
+    removeTag?: number[] | undefined;
+    syncQiWei?: boolean | undefined;
+}>;
+export declare function batchUpdateCustomerTag(client: KeceClient, params: z.infer<typeof batchUpdateTagSchema>): Promise<{
+    message: string;
+    successCount: number;
+    failCount: number;
+    failList: number[];
+}>;

package/dist/tools/customer-tag.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+export const updateCustomerTagSchema = z.object({
+    cid: z.number().optional().describe("客户ID（cid 和 externalUserid 二选一）"),
+    externalUserid: z.string().optional().describe("企微 external_userid"),
+    tagGroupId: z.number().describe("标签组ID（通过 get_customer_fields 查询获得）"),
+    addTag: z.array(z.number()).optional().describe("要添加的标签ID列表"),
+    removeTag: z.array(z.number()).optional().describe("要移除的标签ID列表"),
+    syncQiWei: z.boolean().optional().default(false).describe("是否同步到企微标签"),
+});
+export async function updateCustomerTag(client, params) {
+    if (!params.cid && !params.externalUserid) {
+        return { success: false, message: "请提供 cid 或 externalUserid" };
+    }
+    if (!params.addTag?.length && !params.removeTag?.length) {
+        return { success: false, message: "请至少提供 addTag 或 removeTag" };
+    }
+    const body = {
+        tagGroupId: params.tagGroupId,
+        syncQiWei: params.syncQiWei,
+    };
+    if (params.cid)
+        body.cid = params.cid;
+    if (params.externalUserid)
+        body.externalUserid = params.externalUserid;
+    if (params.addTag?.length)
+        body.addTag = params.addTag;
+    if (params.removeTag?.length)
+        body.removeTag = params.removeTag;
+    await client.request("/openapi/customer/updateCustomerTag", body);
+    const actions = [];
+    if (params.addTag?.length)
+        actions.push(`添加 ${params.addTag.length} 个标签`);
+    if (params.removeTag?.length)
+        actions.push(`移除 ${params.removeTag.length} 个标签`);
+    return {
+        success: true,
+        message: `已为客户 ${params.cid || params.externalUserid} ${actions.join("、")}`,
+        syncQiWei: params.syncQiWei,
+    };
+}
+export const batchUpdateTagSchema = z.object({
+    cidList: z.array(z.number()).describe("客户ID列表"),
+    tagGroupId: z.number().describe("标签组ID"),
+    addTag: z.array(z.number()).optional().describe("要添加的标签ID列表"),
+    removeTag: z.array(z.number()).optional().describe("要移除的标签ID列表"),
+    syncQiWei: z.boolean().optional().default(false).describe("是否同步到企微"),
+});
+export async function batchUpdateCustomerTag(client, params) {
+    const results = { success: 0, fail: 0, failList: [] };
+    const concurrency = 10;
+    for (let i = 0; i < params.cidList.length; i += concurrency) {
+        const batch = params.cidList.slice(i, i + concurrency);
+        const promises = batch.map(async (cid) => {
+            try {
+                await updateCustomerTag(client, {
+                    cid,
+                    tagGroupId: params.tagGroupId,
+                    addTag: params.addTag,
+                    removeTag: params.removeTag,
+                    syncQiWei: params.syncQiWei,
+                });
+                results.success++;
+            }
+            catch {
+                results.fail++;
+                results.failList.push(cid);
+            }
+        });
+        await Promise.all(promises);
+    }
+    return {
+        message: `批量打标签完成：成功 ${results.success}，失败 ${results.fail}`,
+        successCount: results.success,
+        failCount: results.fail,
+        failList: results.failList,
+    };
+}

package/dist/tools/helpers.d.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import type { KeceClient } from "../client.js";
+export declare const getCustomerFieldsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare function getCustomerFields(client: KeceClient): Promise<{
+    fields: any;
+}>;
+export declare const listStaffSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    usingStatus: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    page: number;
+    pageSize: number;
+    usingStatus: number;
+}, {
+    page?: number | undefined;
+    pageSize?: number | undefined;
+    usingStatus?: number | undefined;
+}>;
+export declare function listStaff(client: KeceClient, params: z.infer<typeof listStaffSchema>): Promise<{
+    total: any;
+    staffs: any;
+}>;
+export declare const listSegmentsSchema: z.ZodObject<{
+    keyword: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    keyword?: string | undefined;
+}, {
+    keyword?: string | undefined;
+}>;
+export declare function listSegments(client: KeceClient, params: z.infer<typeof listSegmentsSchema>): Promise<{
+    total: any;
+    segments: any;
+}>;
+export declare const createSegmentSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description?: string | undefined;
+}, {
+    name: string;
+    description?: string | undefined;
+}>;
+export declare function createSegment(client: KeceClient, params: z.infer<typeof createSegmentSchema>): Promise<{
+    success: boolean;
+    segmentId: any;
+    message: string;
+}>;
+export declare const importSegmentSchema: z.ZodObject<{
+    segmentId: z.ZodNumber;
+    cidList: z.ZodArray<z.ZodNumber, "many">;
+    accountType: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    cidList: number[];
+    segmentId: number;
+    accountType: number;
+}, {
+    cidList: number[];
+    segmentId: number;
+    accountType?: number | undefined;
+}>;
+export declare function importSegment(client: KeceClient, params: z.infer<typeof importSegmentSchema>): Promise<{
+    success: boolean;
+    message: string;
+}>;
+export declare const listMassSendTasksSchema: z.ZodObject<{
+    pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    pageSize: number;
+}, {
+    pageSize?: number | undefined;
+}>;
+export declare function listMassSendTasks(client: KeceClient, params: z.infer<typeof listMassSendTasksSchema>): Promise<{
+    total: any;
+    tasks: any;
+}>;

package/dist/tools/helpers.js

@@ -0,0 +1,135 @@
+import { z } from "zod";
+// ===== 查询客户字段 =====
+export const getCustomerFieldsSchema = z.object({});
+export async function getCustomerFields(client) {
+    const result = await client.request("/openapi/customer/fields", {});
+    const fields = result.data || [];
+    return {
+        fields: fields.map((f) => ({
+            id: f.id,
+            name: f.name,
+            type: f.type,
+            typeLabel: formatFieldType(f.type),
+            status: f.status,
+            options: f.options?.map((o) => ({ id: o.id, value: o.optionValue })) || [],
+        })),
+    };
+}
+function formatFieldType(type) {
+    const map = {
+        1: "单行文本", 2: "多行文本", 3: "数字",
+        4: "单选标签", 5: "多选标签", 8: "日期",
+        9: "时间", 10: "日期+时间", 11: "标签", 12: "头像",
+    };
+    return map[type] || `类型${type}`;
+}
+// ===== 查询员工列表 =====
+export const listStaffSchema = z.object({
+    page: z.number().optional().default(1).describe("页码"),
+    pageSize: z.number().optional().default(100).describe("每页数量，最大100"),
+    usingStatus: z.number().optional().default(1).describe("员工状态：-1=所有, 0=停用, 1=启用"),
+});
+export async function listStaff(client, params) {
+    const result = await client.request("/openapi/ent/listStaff", {
+        page: params.page,
+        pageSize: params.pageSize,
+        usingStatus: params.usingStatus,
+        recursive: true,
+    });
+    const data = result.data || result;
+    const staffs = data.staffs || [];
+    return {
+        total: data.total || 0,
+        staffs: staffs.map((s) => ({
+            accid: s.accid,
+            name: s.nick,
+            role: formatRole(s.role),
+            mobile: s.mobile,
+            department: s.depts?.map((d) => d.name).join("/") || "",
+        })),
+    };
+}
+function formatRole(role) {
+    const map = {
+        1: "企业所有者", 2: "管理员", 3: "销售", 4: "运营", 5: "销售主管",
+    };
+    return map[role] || `角色${role}`;
+}
+// ===== 查询人群包列表 =====
+export const listSegmentsSchema = z.object({
+    keyword: z.string().optional().describe("搜索关键词（ID或名称）"),
+});
+export async function listSegments(client, params) {
+    const body = {};
+    if (params.keyword)
+        body.keyword = params.keyword;
+    const result = await client.request("/openapi/cdp/segment/list", body);
+    const data = result.data || {};
+    const segments = data.contents || data.list || (Array.isArray(data) ? data : []);
+    return {
+        total: data.total || segments.length,
+        segments: segments.map((s) => ({
+            id: s.id || s.segmentId,
+            name: s.name,
+            type: s.type,
+            count: s.count || s.customerCount,
+            updateTime: s.updateTime ? new Date(s.updateTime).toISOString().slice(0, 10) : "",
+        })),
+    };
+}
+// ===== 创建人群包 =====
+export const createSegmentSchema = z.object({
+    name: z.string().describe("人群包名称"),
+    description: z.string().optional().describe("描述"),
+});
+export async function createSegment(client, params) {
+    const result = await client.request("/openapi/cdp/segment/create", {
+        name: params.name,
+        description: params.description || "",
+    });
+    return {
+        success: true,
+        segmentId: result.data,
+        message: `人群包「${params.name}」已创建（ID: ${result.data}）`,
+    };
+}
+// ===== 导入用户到人群包 =====
+export const importSegmentSchema = z.object({
+    segmentId: z.number().describe("人群包ID"),
+    cidList: z.array(z.number()).describe("客户ID列表"),
+    accountType: z.number().optional().default(3).describe("账号类型，3=CID"),
+});
+export async function importSegment(client, params) {
+    const result = await client.request("/openapi/cdp/segment/import", {
+        segmentId: params.segmentId,
+        cidList: params.cidList,
+        accountType: params.accountType,
+    });
+    return {
+        success: true,
+        message: `已导入 ${params.cidList.length} 位用户到人群包（ID: ${params.segmentId}）`,
+    };
+}
+// ===== 查询群发任务列表 =====
+export const listMassSendTasksSchema = z.object({
+    pageSize: z.number().optional().default(20).describe("每页数量，最大100"),
+});
+export async function listMassSendTasks(client, params) {
+    const result = await client.request("/openapi/wxWork/send/msg/list/v2", {
+        pageSize: params.pageSize,
+    });
+    const tasks = result.data || [];
+    return {
+        total: tasks.length,
+        tasks: tasks.map((t) => ({
+            taskId: t.sendTaskId,
+            status: formatTaskStatus(t.flag),
+            content: t.content?.slice(0, 50) || "",
+            createTime: t.createTime ? new Date(t.createTime).toISOString().slice(0, 16).replace("T", " ") : "",
+        })),
+    };
+}
+function formatTaskStatus(flag) {
+    const map = { 1: "已开始", 2: "未开始", 3: "已取消" };
+    return map[flag] || `状态${flag}`;
+}

package/dist/tools/mass-send.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import type { KeceClient } from "../client.js";
+export declare const createMassSendSchema: z.ZodObject<{
+    type: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    wxfollowers: z.ZodArray<z.ZodString, "many">;
+    textContent: z.ZodOptional<z.ZodString>;
+    medias: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        sendType: z.ZodNumber;
+        picUrl: z.ZodOptional<z.ZodString>;
+        linkUrl: z.ZodOptional<z.ZodString>;
+        linkTitle: z.ZodOptional<z.ZodString>;
+        linkContent: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        sendType: number;
+        picUrl?: string | undefined;
+        linkUrl?: string | undefined;
+        linkTitle?: string | undefined;
+        linkContent?: string | undefined;
+    }, {
+        sendType: number;
+        picUrl?: string | undefined;
+        linkUrl?: string | undefined;
+        linkTitle?: string | undefined;
+        linkContent?: string | undefined;
+    }>, "many">>;
+    filterType: z.ZodEnum<["quick", "advanced", "segment"]>;
+    filterFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        fieldId: z.ZodString;
+        filterType: z.ZodNumber;
+        filterValue: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        fieldId: string;
+        filterType: number;
+        filterValue?: string | undefined;
+    }, {
+        fieldId: string;
+        filterType: number;
+        filterValue?: string | undefined;
+    }>, "many">>;
+    segmentIds: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    sendInterval: z.ZodOptional<z.ZodNumber>;
+    sendNumOnetime: z.ZodOptional<z.ZodNumber>;
+    allowAutoSend: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    categoryName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: number;
+    filterType: "quick" | "advanced" | "segment";
+    wxfollowers: string[];
+    allowAutoSend: boolean;
+    filterFields?: {
+        fieldId: string;
+        filterType: number;
+        filterValue?: string | undefined;
+    }[] | undefined;
+    segmentIds?: number[] | undefined;
+    textContent?: string | undefined;
+    medias?: {
+        sendType: number;
+        picUrl?: string | undefined;
+        linkUrl?: string | undefined;
+        linkTitle?: string | undefined;
+        linkContent?: string | undefined;
+    }[] | undefined;
+    sendInterval?: number | undefined;
+    sendNumOnetime?: number | undefined;
+    categoryName?: string | undefined;
+}, {
+    filterType: "quick" | "advanced" | "segment";
+    wxfollowers: string[];
+    type?: number | undefined;
+    filterFields?: {
+        fieldId: string;
+        filterType: number;
+        filterValue?: string | undefined;
+    }[] | undefined;
+    segmentIds?: number[] | undefined;
+    textContent?: string | undefined;
+    medias?: {
+        sendType: number;
+        picUrl?: string | undefined;
+        linkUrl?: string | undefined;
+        linkTitle?: string | undefined;
+        linkContent?: string | undefined;
+    }[] | undefined;
+    sendInterval?: number | undefined;
+    sendNumOnetime?: number | undefined;
+    allowAutoSend?: boolean | undefined;
+    categoryName?: string | undefined;
+}>;
+export declare function createMassSend(client: KeceClient, params: z.infer<typeof createMassSendSchema>): Promise<{
+    success: boolean;
+    message: string;
+    taskId?: undefined;
+    type?: undefined;
+} | {
+    success: boolean;
+    taskId: any;
+    message: string;
+    type: string;
+}>;

package/dist/tools/mass-send.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+const mediaSchema = z.object({
+    sendType: z.number().describe("发送类型：1=链接, 2=图片, 3=小程序"),
+    picUrl: z.string().optional().describe("图片地址"),
+    linkUrl: z.string().optional().describe("链接地址"),
+    linkTitle: z.string().optional().describe("链接标题"),
+    linkContent: z.string().optional().describe("链接描述"),
+});
+const filterFieldSchema = z.object({
+    fieldId: z.string().describe("筛选字段ID"),
+    filterType: z.number().describe("筛选条件类型"),
+    filterValue: z.string().optional().describe("筛选值"),
+});
+export const createMassSendSchema = z.object({
+    type: z.number().optional().default(0).describe("任务类型：0=客户群发, 4=RPA群发"),
+    wxfollowers: z.array(z.string()).describe("发送人 accid 列表（从 list_staff 获取）"),
+    textContent: z.string().optional().describe("文本消息内容（最长4000字符），与 medias 至少有一个"),
+    medias: z.array(mediaSchema).optional().describe("附件列表"),
+    filterType: z
+        .enum(["quick", "advanced", "segment"])
+        .describe("人群筛选模式：quick=快捷筛选, advanced=高级筛选, segment=客层筛选"),
+    filterFields: z.array(filterFieldSchema).optional().describe("筛选字段（quick/advanced 模式）"),
+    segmentIds: z.array(z.number()).optional().describe("客层ID列表（segment 模式）"),
+    sendInterval: z.number().optional().describe("发送间隔（分钟）"),
+    sendNumOnetime: z.number().optional().describe("每批次发送客户数（不小于1000）"),
+    allowAutoSend: z.boolean().optional().default(false).describe("是否自动发送"),
+    categoryName: z.string().optional().describe("分类名称"),
+});
+const FILTER_TYPE_MAP = {
+    quick: 1,
+    advanced: 3,
+    segment: 2,
+};
+export async function createMassSend(client, params) {
+    if (!params.textContent && !params.medias?.length) {
+        return { success: false, message: "文本内容和附件至少提供一个" };
+    }
+    const queryFilter = { type: FILTER_TYPE_MAP[params.filterType] };
+    if (params.filterType === "segment") {
+        queryFilter.segmentIds = params.segmentIds || [];
+    }
+    else {
+        queryFilter.filterContent = {
+            filterFields: (params.filterFields || []).map((f) => ({
+                fieldId: f.fieldId,
+                filterType: f.filterType,
+                filterValue: f.filterValue || "",
+            })),
+        };
+    }
+    const body = {
+        type: params.type,
+        batchDo: true,
+        taskType: "task",
+        allowAutoSend: params.allowAutoSend,
+        allowSelect: false,
+        botUseScope: { switchFlag: 0 },
+        categoryId: 0,
+        cdp: params.filterType === "segment",
+        needRemoveDup: false,
+        personalizedConfSwitch: 0,
+        segmentSplit: false,
+        timeType: 1,
+        customerType: 1,
+        queryFilter,
+        welcomeMessage: {
+            welcomeMsg: params.textContent || "",
+            medias: (params.medias || []).map((m) => ({
+                sendType: m.sendType,
+                mediaType: 0,
+                picUrl: m.picUrl || "",
+                linkUrl: m.linkUrl || "",
+                linkTitle: m.linkTitle || "",
+                linkContent: m.linkContent || "",
+            })),
+            mediaType: 0,
+            sendType: 0,
+        },
+        wxfollowers: params.wxfollowers,
+    };
+    if (params.sendInterval)
+        body.sendInterval = params.sendInterval;
+    if (params.sendNumOnetime)
+        body.sendNumOnetime = params.sendNumOnetime;
+    if (params.categoryName)
+        body.categoryName = params.categoryName;
+    const result = await client.request("/openapi/wxWork/send/msg/createByAudience", body);
+    return {
+        success: true,
+        taskId: result.data,
+        message: `群发任务已创建（ID: ${result.data}）`,
+        type: params.type === 4 ? "RPA群发（自动直发）" : "普通群发（需员工确认）",
+    };
+}

package/dist/tools/resolve-ids.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { KeceClient } from "../client.js";
+export declare const resolveIdsSchema: z.ZodObject<{
+    direction: z.ZodEnum<["account_to_cid", "cid_to_account"]>;
+    ids: z.ZodArray<z.ZodString, "many">;
+    fieldId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    direction: "account_to_cid" | "cid_to_account";
+    ids: string[];
+    fieldId?: string | undefined;
+}, {
+    direction: "account_to_cid" | "cid_to_account";
+    ids: string[];
+    fieldId?: string | undefined;
+}>;
+export declare function resolveIds(client: KeceClient, params: z.infer<typeof resolveIdsSchema>): Promise<any>;

package/dist/tools/resolve-ids.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+export const resolveIdsSchema = z.object({
+    direction: z
+        .enum(["account_to_cid", "cid_to_account"])
+        .describe("转换方向：account_to_cid=游戏账号ID转科策CID, cid_to_account=科策CID转游戏账号ID"),
+    ids: z.array(z.string()).describe("要转换的ID列表"),
+    fieldId: z
+        .string()
+        .optional()
+        .describe("存储游戏账号ID的科策自定义字段ID。不传则使用环境变量 KECE_GAME_ACCOUNT_FIELD_ID"),
+});
+export async function resolveIds(client, params) {
+    const fieldId = params.fieldId || process.env.KECE_GAME_ACCOUNT_FIELD_ID;
+    if (!fieldId) {
+        return {
+            success: false,
+            message: "未配置游戏账号字段ID。请传入 fieldId 参数，或设置环境变量 KECE_GAME_ACCOUNT_FIELD_ID。可通过 get_customer_fields 查询所有字段找到对应ID。",
+        };
+    }
+    if (params.direction === "account_to_cid") {
+        return resolveAccountToCid(client, params.ids, fieldId);
+    }
+    else {
+        return resolveCidToAccount(client, params.ids, fieldId);
+    }
+}
+async function resolveAccountToCid(client, accountIds, fieldId) {
+    const results = [];
+    for (const accountId of accountIds) {
+        const resp = await client.request("/openapi/customer/search", {
+            customerType: 1,
+            page: 1,
+            pageSize: 1,
+            queryFilter: {
+                type: 1,
+                filterContent: {
+                    filterFields: [{ fieldId, filterType: 5, filterValue: accountId }],
+                },
+            },
+        });
+        const list = resp.data?.customerList || [];
+        results.push({
+            accountId,
+            cid: list.length > 0 ? list[0].cid : null,
+        });
+    }
+    const matched = results.filter((r) => r.cid !== null);
+    return {
+        success: true,
+        total: accountIds.length,
+        matched: matched.length,
+        unmatched: accountIds.length - matched.length,
+        results,
+    };
+}
+async function resolveCidToAccount(client, cids, fieldId) {
+    const results = [];
+    for (const cid of cids) {
+        const resp = await client.request("/openapi/customer/query", {
+            type: 3,
+            targets: [cid],
+        });
+        const customers = resp.data || [];
+        let accountId = null;
+        if (customers.length > 0) {
+            const field = (customers[0].customFields || []).find((f) => String(f.id) === fieldId);
+            accountId = field?.fieldValue || null;
+        }
+        results.push({ cid, accountId });
+    }
+    const matched = results.filter((r) => r.accountId !== null);
+    return {
+        success: true,
+        total: cids.length,
+        matched: matched.length,
+        unmatched: cids.length - matched.length,
+        results,
+    };
+}

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "kece-skill-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.0",
+  "description": "科策SCRM智能运营 MCP Server - 查客户/打标签/圈人/群发/数数ID打通",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "kece-skill-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.