dingtalk-dws-mcp 1.0.0

package/dist/src/internal/dws-robot-command.js

@@ -0,0 +1,27 @@
+import * as path from "node:path";
+import { sendRobotMessage as libSendRobotMessage, } from "agent-compose-notify-delivery";
+export async function sendRobotMessage(config, request, runner, env = process.env) {
+    if (!config.clientId || !config.clientSecret || !config.robotCode) {
+        return {
+            status: "failed",
+            errorCode: "ADAPTER_UNAUTHORIZED",
+            error: "Robot application credentials are required",
+        };
+    }
+    return libSendRobotMessage({
+        dwsCommand: config.dwsCommand,
+        clientId: config.clientId,
+        clientSecret: config.clientSecret,
+        robotCode: config.robotCode,
+        configDir: path.join(config.stateDir, "dws-robot"),
+        timeoutMs: config.timeoutMs,
+        maxOutputBytes: config.maxOutputBytes,
+        runner,
+        env,
+    }, {
+        routeType: request.routeType,
+        targetId: request.targetId,
+        title: request.title,
+        content: request.content,
+    });
+}

package/dist/src/internal/exec.d.ts

@@ -0,0 +1,21 @@
+export type CommandRunner = (file: string, args: readonly string[], options: {
+    timeout: number;
+    maxBuffer: number;
+    env: NodeJS.ProcessEnv;
+    windowsHide: boolean;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function pickEnv(names: readonly string[], env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function userDwsEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function runCommand(command: string, args: readonly string[], options: {
+    timeoutMs: number;
+    maxOutputBytes: number;
+    env: NodeJS.ProcessEnv;
+    runner?: CommandRunner;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function parseJsonObject(stdout: string): Record<string, unknown>;

package/dist/src/internal/exec.js

@@ -0,0 +1,59 @@
+/**
+ * Internal runtime dependency only.
+ * Not an exposed command-execution interface.
+ * Agent must never gain arbitrary `dws <anything>` through this layer.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { redact } from "agent-compose-notify-delivery";
+const execFileAsync = promisify(execFile);
+const USER_DWS_ENV = [
+    "HOME", "USERPROFILE", "PATH", "USER", "LOGNAME", "TMPDIR", "TEMP", "TMP",
+    "XDG_CONFIG_HOME", "XDG_DATA_HOME", "BROWSER", "DISPLAY", "WAYLAND_DISPLAY",
+    "NODE_EXTRA_CA_CERTS", "DWS_CONFIG_DIR",
+];
+export function pickEnv(names, env) {
+    const result = {};
+    for (const name of names) {
+        if (env[name] !== undefined)
+            result[name] = env[name];
+    }
+    return result;
+}
+export function userDwsEnv(env = process.env) {
+    return pickEnv(USER_DWS_ENV, env);
+}
+export async function runCommand(command, args, options) {
+    const runner = options.runner ?? execFileAsync;
+    try {
+        return await runner(command, args, {
+            timeout: options.timeoutMs,
+            maxBuffer: options.maxOutputBytes,
+            env: options.env,
+            windowsHide: true,
+        });
+    }
+    catch (error) {
+        const details = error && typeof error === "object" ? error : {};
+        const stdout = typeof details.stdout === "string" ? details.stdout : "";
+        const stderr = typeof details.stderr === "string" ? details.stderr : "";
+        const message = error instanceof Error ? error.message : String(error);
+        const wrapped = Object.assign(new Error(redact(`${message}\n${stdout}\n${stderr}`)), {
+            code: details.code,
+            killed: details.killed,
+            stdout: redact(stdout),
+            stderr: redact(stderr),
+        });
+        throw wrapped;
+    }
+}
+export function parseJsonObject(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        throw new Error("Command produced no JSON output");
+    const value = JSON.parse(trimmed);
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Command returned non-object JSON");
+    }
+    return value;
+}

package/dist/src/notify/bind.d.ts

@@ -0,0 +1,7 @@
+import type { AppConfig, RouteName, RouteType, TargetCandidate } from "../types.js";
+export declare function candidateRef(candidate: TargetCandidate): string;
+export declare function readTargets(config: AppConfig): Record<string, string>;
+export declare function writeTarget(config: AppConfig, route: RouteName, targetId: string): void;
+export declare function resolveRouteTarget(config: AppConfig, route: RouteName): string;
+export declare function routeType(route: RouteName): RouteType;
+export declare function isRouteConfigured(config: AppConfig, route: RouteName): boolean;

package/dist/src/notify/bind.js

@@ -0,0 +1,44 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createHash } from "node:crypto";
+import { DingtalkDwsError } from "../errors.js";
+export function candidateRef(candidate) {
+    return `candidate_${createHash("sha256").update(`${candidate.type}\n${candidate.target_id}`).digest("hex")}`;
+}
+export function readTargets(config) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(config.targetsPath, "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        // first bind
+    }
+    return {};
+}
+export function writeTarget(config, route, targetId) {
+    fs.mkdirSync(path.dirname(config.targetsPath), { recursive: true, mode: 0o700 });
+    const targets = readTargets(config);
+    targets[route] = targetId;
+    fs.writeFileSync(config.targetsPath, `${JSON.stringify(targets, null, 2)}\n`, { mode: 0o600 });
+}
+export function resolveRouteTarget(config, route) {
+    if (config.adapter === "webhook") {
+        if (route !== "notify_group") {
+            throw new DingtalkDwsError("ADAPTER_UNSUPPORTED", "Webhook only supports notify_group");
+        }
+        return "webhook";
+    }
+    const target = readTargets(config)[route];
+    if (!target)
+        throw new DingtalkDwsError("INVALID_ARGUMENT", `Route ${route} has no bound target`);
+    return target;
+}
+export function routeType(route) {
+    return route === "notify_group" ? "group" : "user";
+}
+export function isRouteConfigured(config, route) {
+    if (config.adapter === "webhook")
+        return route === "notify_group" && Boolean(config.webhookUrl);
+    return Boolean(readTargets(config)[route]);
+}

package/dist/src/notify/content.d.ts

@@ -0,0 +1,2 @@
+import type { AppConfig, SendInput } from "../types.js";
+export declare function validateSendContent(input: SendInput, config: AppConfig): void;

package/dist/src/notify/content.js

@@ -0,0 +1,24 @@
+import { DingtalkDwsError } from "../errors.js";
+const SENSITIVE = [
+    { name: "private key", pattern: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/i },
+    { name: "bearer token", pattern: /\bBearer\s+[A-Za-z0-9._~+/-]{16,}={0,2}\b/i },
+    { name: "secret assignment", pattern: /\b(?:clientSecret|appSecret|api[_-]?key|access[_-]?token|password)\s*[:=]\s*[^\s]{8,}/i },
+];
+export function validateSendContent(input, config) {
+    if (!input.title || input.title.length > config.maxTitleLength) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", `title must be 1-${config.maxTitleLength} characters`);
+    }
+    if (!input.content || input.content.length > config.maxContentLength) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", `content must be 1-${config.maxContentLength} characters`);
+    }
+    if (input.dedupe_key && !/^[A-Za-z0-9._:-]{1,160}$/.test(input.dedupe_key)) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", "dedupe_key has an invalid format");
+    }
+    for (const value of [input.title, input.content]) {
+        for (const rule of SENSITIVE) {
+            if (rule.pattern.test(value)) {
+                throw new DingtalkDwsError("CONTENT_REJECTED", `Message contains a possible ${rule.name}`);
+            }
+        }
+    }
+}

package/dist/src/notify/idempotency-store.d.ts

@@ -0,0 +1,16 @@
+export interface ClaimResult {
+    claimed: boolean;
+    state?: "pending" | "sent" | "failed" | "unknown";
+    messageId?: string;
+}
+/** Tiny JSON file store (no SQLite) for optional send dedupe_key. */
+export declare class IdempotencyStore {
+    private readonly memory;
+    private readonly filePath;
+    constructor(databasePath: string);
+    private persist;
+    claim(key: string, nowMs: number, ttlSeconds: number): ClaimResult;
+    mark(key: string, state: NonNullable<ClaimResult["state"]>, messageId?: string): void;
+    close(): void;
+}
+export declare function sha256(value: string): string;

package/dist/src/notify/idempotency-store.js

@@ -0,0 +1,57 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** Tiny JSON file store (no SQLite) for optional send dedupe_key. */
+export class IdempotencyStore {
+    memory = new Map();
+    filePath;
+    constructor(databasePath) {
+        if (databasePath === ":memory:") {
+            this.filePath = null;
+            return;
+        }
+        this.filePath = databasePath;
+        fs.mkdirSync(path.dirname(databasePath), { recursive: true, mode: 0o700 });
+        try {
+            const raw = JSON.parse(fs.readFileSync(databasePath, "utf8"));
+            for (const [key, entry] of Object.entries(raw)) {
+                if (entry && typeof entry.expiresAt === "number")
+                    this.memory.set(key, entry);
+            }
+        }
+        catch {
+            // first use
+        }
+    }
+    persist() {
+        if (!this.filePath)
+            return;
+        const obj = {};
+        for (const [key, entry] of this.memory)
+            obj[key] = entry;
+        fs.writeFileSync(this.filePath, `${JSON.stringify(obj)}\n`, { mode: 0o600 });
+    }
+    claim(key, nowMs, ttlSeconds) {
+        const row = this.memory.get(key);
+        if (row && row.expiresAt > nowMs && row.state !== "failed") {
+            return { claimed: false, state: row.state, messageId: row.messageId };
+        }
+        this.memory.set(key, { state: "pending", expiresAt: nowMs + ttlSeconds * 1000 });
+        this.persist();
+        return { claimed: true };
+    }
+    mark(key, state, messageId) {
+        const row = this.memory.get(key);
+        if (!row)
+            return;
+        row.state = state;
+        row.messageId = messageId;
+        this.persist();
+    }
+    close() {
+        this.persist();
+    }
+}
+export function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}

package/dist/src/patrol/setup.d.ts

@@ -0,0 +1,27 @@
+import type { AppConfig, RouteName } from "../types.js";
+/** Agent-filled args (not mcp.json forms). Delivery credentials come from MCP env → env.sh. */
+export type PatrolSetupInput = {
+    name: string;
+    cron?: string;
+    probe_command?: string;
+    probe_script?: string;
+    route?: RouteName;
+    /** Soft mode: allow missing bind/bundle (tests / preview). Always stages only. */
+    dry_run?: boolean;
+};
+export declare function resolveBundleRoot(env?: NodeJS.ProcessEnv): string;
+export declare function readBundleInfo(env?: NodeJS.ProcessEnv): {
+    available: boolean;
+    bundle_root: string;
+    fingerprint: string | null;
+    server_version: string | null;
+    includes_node: boolean;
+    includes_dws: boolean;
+    message: string;
+};
+/**
+ * Stage offline patrol materials only. Does not SSH/scp.
+ * Agent copies bundle_root + staging_dir to the host (host-execution or SSH), then runs install.sh there.
+ */
+export declare function runPatrolSetup(config: AppConfig, input: PatrolSetupInput, env?: NodeJS.ProcessEnv): Promise<Record<string, unknown>>;
+export declare function bundleFingerprintForDoctor(env?: NodeJS.ProcessEnv): Record<string, unknown>;

package/dist/src/patrol/setup.js

@@ -0,0 +1,213 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { DEFAULT_PATROL_MESSAGE_BODY, DEFAULT_PATROL_MESSAGE_TITLE, } from "agent-compose-notify-delivery";
+import { DingtalkDwsError } from "../errors.js";
+import { isRouteConfigured, readTargets } from "../notify/bind.js";
+import { mcpPackageRoot, readPackageVersion } from "../version.js";
+const DEFAULT_CRON = "*/15 * * * *";
+const DEFAULT_PROBE = `#!/usr/bin/env bash
+set -euo pipefail
+printf '%s\\n' '{"status":"ok","summary":"【进度】示例探针正常\\n【监控】请替换为真实检查","timestamp":"'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'"}'
+`;
+export function resolveBundleRoot(env = process.env) {
+    const override = env.DINGTALK_PATROL_BUNDLE_ROOT?.trim();
+    if (override)
+        return path.resolve(override);
+    return path.join(mcpPackageRoot(), "deploy", "linux-x64");
+}
+export function readBundleInfo(env = process.env) {
+    const bundle_root = resolveBundleRoot(env);
+    const manifestPath = path.join(bundle_root, "manifest.json");
+    const ready = fs.existsSync(manifestPath) && fs.existsSync(path.join(bundle_root, "runtime", "patrol"));
+    if (!ready) {
+        return {
+            available: false,
+            bundle_root,
+            fingerprint: null,
+            server_version: null,
+            includes_node: false,
+            includes_dws: false,
+            message: `Patrol bundle missing at ${bundle_root}. Run npm run pack:deploy.`,
+        };
+    }
+    try {
+        const m = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+        return {
+            available: true,
+            bundle_root,
+            fingerprint: typeof m.fingerprint === "string" ? m.fingerprint : null,
+            server_version: typeof m.server_version === "string" ? m.server_version : null,
+            includes_node: Boolean(m.includes_node),
+            includes_dws: Boolean(m.includes_dws),
+            message: "bundle ready",
+        };
+    }
+    catch {
+        return {
+            available: false,
+            bundle_root,
+            fingerprint: null,
+            server_version: null,
+            includes_node: false,
+            includes_dws: false,
+            message: `Invalid manifest at ${manifestPath}`,
+        };
+    }
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function writeLf(filePath, content, mode) {
+    const body = content.replace(/\r\n/g, "\n");
+    if (mode === undefined)
+        fs.writeFileSync(filePath, body, "utf8");
+    else
+        fs.writeFileSync(filePath, body, { mode });
+}
+/** Sync local notify credentials (already verified by doctor) into target env.sh. Not user OAuth.
+ * Never copy laptop DINGTALK_DWS_COMMAND / config.dwsCommand — that path is Agent-host local
+ * (Windows .exe or Linux absolute) and is wrong on the patrol target. Target resolves `dws` via
+ * install runtime PATH (bundled linux ELF) or system dws. Optional target-only override:
+ * DINGTALK_PATROL_HOST_DWS (path that exists on the target machine).
+ */
+function writeEnvFile(filePath, config, env) {
+    const lines = ["# Generated by dingtalk_patrol_setup — delivery credentials for target host"];
+    const put = (key, value) => {
+        if (value)
+            lines.push(`export ${key}=${shellQuote(value)}`);
+    };
+    put("DINGTALK_CLIENT_ID", config.clientId ?? env.DINGTALK_CLIENT_ID);
+    put("DINGTALK_CLIENT_SECRET", config.clientSecret ?? env.DINGTALK_CLIENT_SECRET);
+    put("DINGTALK_ROBOT_CODE", config.robotCode ?? env.DINGTALK_ROBOT_CODE);
+    put("DINGTALK_WEBHOOK_URL", config.webhookUrl ?? env.DINGTALK_WEBHOOK_URL);
+    put("DINGTALK_WEBHOOK_SECRET", config.webhookSecret ?? env.DINGTALK_WEBHOOK_SECRET);
+    const hostDws = env.DINGTALK_PATROL_HOST_DWS?.trim();
+    if (hostDws)
+        put("DINGTALK_DWS_COMMAND", hostDws);
+    writeLf(filePath, `${lines.join("\n")}\n`, 0o600);
+}
+function pickRoute(config, preferred) {
+    if (config.adapter === "webhook")
+        return "notify_group";
+    if (preferred) {
+        if (!isRouteConfigured(config, preferred)) {
+            throw new DingtalkDwsError("INVALID_ARGUMENT", `Route ${preferred} is not bound`);
+        }
+        return preferred;
+    }
+    if (isRouteConfigured(config, "notify_group"))
+        return "notify_group";
+    if (isRouteConfigured(config, "notify_user"))
+        return "notify_user";
+    throw new DingtalkDwsError("INVALID_ARGUMENT", "Bind a notify target first (or use webhook)");
+}
+function buildYaml(options) {
+    const delivery = [`  type: ${options.deliveryType}`];
+    if (options.target)
+        delivery.push(`  ${options.target.field}: ${JSON.stringify(options.target.id)}`);
+    const body = DEFAULT_PATROL_MESSAGE_BODY.split("\n").map((l) => `    ${l}`).join("\n");
+    return `name: ${options.name}
+cron: ${JSON.stringify(options.cron)}
+probe:
+  exec:
+    command: ${JSON.stringify(options.probeCommand)}
+    timeout_sec: 60
+delivery:
+${delivery.join("\n")}
+template:
+  title: ${JSON.stringify(DEFAULT_PATROL_MESSAGE_TITLE)}
+  body: |
+${body}
+`;
+}
+/**
+ * Stage offline patrol materials only. Does not SSH/scp.
+ * Agent copies bundle_root + staging_dir to the host (host-execution or SSH), then runs install.sh there.
+ */
+export async function runPatrolSetup(config, input, env = process.env) {
+    const name = input.name.trim();
+    if (!name || name.includes("/") || name.includes("\\") || name.includes("..")) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", "name must be a single path segment");
+    }
+    if (!config.adapter) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", "Set DINGTALK_CLIENT_ID/SECRET or DINGTALK_WEBHOOK_URL in MCP env");
+    }
+    const cron = input.cron?.trim() || DEFAULT_CRON;
+    const bundle = readBundleInfo(env);
+    if (!bundle.available && !input.dry_run) {
+        throw new DingtalkDwsError("ADAPTER_UNAVAILABLE", bundle.message);
+    }
+    const route = pickRoute(config, input.route);
+    const deliveryType = config.adapter;
+    let target;
+    if (deliveryType === "dws") {
+        if (!isRouteConfigured(config, route) && !input.dry_run) {
+            throw new DingtalkDwsError("INVALID_ARGUMENT", `Bind ${route} before setup`);
+        }
+        const id = readTargets(config)[route];
+        if (id) {
+            target = route === "notify_group"
+                ? { field: "open_conversation_id", id }
+                : { field: "user_id", id };
+        }
+    }
+    const stagingRoot = path.join(env.DINGTALK_PATROL_STAGING_DIR?.trim()
+        ? path.resolve(env.DINGTALK_PATROL_STAGING_DIR)
+        : path.join(os.tmpdir(), "dingtalk-patrol-staging"), name);
+    fs.mkdirSync(path.join(stagingRoot, "probes"), { recursive: true, mode: 0o700 });
+    const probeCommand = input.probe_command?.trim() || "./probes/example.sh";
+    const probeFile = path.join(stagingRoot, "probes", path.basename(probeCommand) === probeCommand ? "example.sh" : path.basename(probeCommand));
+    const script = input.probe_script ?? DEFAULT_PROBE;
+    writeLf(probeFile, script.endsWith("\n") ? script : `${script}\n`, 0o755);
+    const yamlPath = path.join(stagingRoot, "patrol.yaml");
+    const envPath = path.join(stagingRoot, "env.sh");
+    writeLf(yamlPath, buildYaml({
+        name,
+        cron,
+        probeCommand: probeCommand.includes("/") || probeCommand.includes("\\")
+            ? probeCommand
+            : `./probes/${path.basename(probeFile)}`,
+        deliveryType,
+        target,
+    }));
+    writeEnvFile(envPath, config, env);
+    const response = {
+        ok: true,
+        name,
+        cron,
+        route,
+        next_action: "install_on_host",
+        staging_dir: stagingRoot,
+        bundle_root: bundle.bundle_root,
+        bundle_fingerprint: bundle.fingerprint,
+        includes_node: bundle.includes_node,
+        includes_dws: bundle.includes_dws,
+        install_hint: "Copy bundle_root (runtime+install.sh) and staging_dir to the host, then run: install.sh <staging>",
+        server_version: readPackageVersion(),
+        paths: { yaml: yamlPath, env: envPath, probe: probeFile },
+    };
+    if (deliveryType === "dws" && bundle.available && !bundle.includes_dws) {
+        response.warning =
+            "bundle includes_dws=false: target needs system dws on PATH, or re-pack with linux ELF (DINGTALK_PATROL_DWS_PATH)";
+    }
+    const serialized = JSON.stringify(response);
+    for (const secret of [config.clientSecret, config.webhookSecret, env.DINGTALK_CLIENT_SECRET, env.DINGTALK_WEBHOOK_SECRET]) {
+        if (secret && serialized.includes(secret)) {
+            throw new DingtalkDwsError("INTERNAL_ERROR", "refusing to return secrets");
+        }
+    }
+    return response;
+}
+export function bundleFingerprintForDoctor(env = process.env) {
+    const info = readBundleInfo(env);
+    return {
+        available: info.available,
+        fingerprint: info.fingerprint,
+        server_version: info.server_version ?? readPackageVersion(),
+        includes_node: info.includes_node,
+        includes_dws: info.includes_dws,
+        path: info.bundle_root,
+        message: info.message,
+    };
+}

package/dist/src/prompts.d.ts

@@ -0,0 +1,21 @@
+/**
+ * MCP prompts = user-controlled recipes (slash / menu).
+ * Do NOT put server-wide constraints here — those belong in initialize `instructions`.
+ * Do NOT put per-tool when/when-not here — that belongs in tool `description`.
+ */
+import type { ToolSurface } from "./tools/registry.js";
+export type PromptDefinition = {
+    name: string;
+    description: string;
+};
+export declare function listPromptDefinitions(_surface: ToolSurface): PromptDefinition[];
+export declare function getPromptMessages(name: string): {
+    description: string;
+    messages: Array<{
+        role: "user";
+        content: {
+            type: "text";
+            text: string;
+        };
+    }>;
+};

package/dist/src/prompts.js

@@ -0,0 +1,37 @@
+const NOTIFY_RECIPE = `One-shot DingTalk notify (user-selected recipe):
+1. dingtalk_doctor → follow next_action
+2. Managed: search → bind → dingtalk_send (route, title, content)
+3. Webhook: dingtalk_send with route=notify_group only`;
+const PATROL_RECIPE = `Host Patrol Runtime (user-selected recipe):
+1. dingtalk_doctor (credentials in MCP env only)
+2. Managed: bind notify target if needed
+3. From conversation: host + what to check + how often → call dingtalk_patrol_setup once (stages materials + delivery credentials)
+4. Copy bundle_root + staging_dir to the host (host-execution if available, else SSH with user-provided IP/user/password or key), run install.sh on the host
+5. Stop — do not download Node on the laptop`;
+export function listPromptDefinitions(_surface) {
+    return [
+        {
+            name: "dingtalk_notify",
+            description: "User recipe: send one DingTalk notification with this server's tools.",
+        },
+        {
+            name: "dingtalk_patrol",
+            description: "User recipe: set up host-side Patrol Runtime (not a session loop).",
+        },
+    ];
+}
+export function getPromptMessages(name) {
+    if (name === "dingtalk_notify") {
+        return {
+            description: "One-shot notify recipe",
+            messages: [{ role: "user", content: { type: "text", text: NOTIFY_RECIPE } }],
+        };
+    }
+    if (name === "dingtalk_patrol") {
+        return {
+            description: "Host patrol setup recipe",
+            messages: [{ role: "user", content: { type: "text", text: PATROL_RECIPE } }],
+        };
+    }
+    throw new Error(`Unknown prompt: ${name}`);
+}

package/dist/src/server.d.ts

@@ -0,0 +1,44 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { IdempotencyStore } from "./notify/idempotency-store.js";
+import { DingtalkDwsService } from "./service.js";
+export declare const MCP_SERVER_NAME = "dingtalk-dws";
+export declare const MCP_SERVER_VERSION: string;
+export declare function createMcpServer(service?: DingtalkDwsService, store?: IdempotencyStore): {
+    server: Server<{
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    service: DingtalkDwsService;
+    store: IdempotencyStore;
+};
+export declare function runStdioServer(): Promise<void>;