dingtalk-dws-mcp 1.0.2 → 1.1.0

package/README.md

@@ -4,18 +4,30 @@
 
 Agent：`instructions` / tool `description` / `prompts` / **Resources（`guides/*.md`）**。长期巡检：`dingtalk_patrol_setup` 备料 → 传装到主机 → 停。
 
+本目录为唯一工程根：
+
+```text
+packages/mcp/dingtalk-dws-mcp/
+  src/                 # MCP server（含 patrol-setup；build 时从 lib 同步 notify-delivery）
+  lib/notify-delivery/ # L0 投递（仓内唯一源；不单独发 npm）
+  host-patrol/         # 主机巡检 CLI 源码（pack:deploy 用；不进 MCP npm tarball）
+  guides/              # MCP Resources
+```
+
+部署产物仍使用 `deploy/linux-x64/runtime/patrol/`（与 `install.sh` 路径约定一致）；勿与源码目录 `host-patrol/`、`src/patrol-setup/` 混淆。
+
 ## 构建
 
 ```bash
-cd packages/lib/notify-delivery && npm install && npm run build
-cd ../../mcp/dingtalk-dws-mcp && npm install && npm run build
-npm run pack:deploy
+cd packages/mcp/dingtalk-dws-mcp
+npm install && npm run build
+npm run pack:deploy   # 可选：生成 deploy/linux-x64 巡检包（仅 monorepo）
 ```
 
-`pack:deploy` 生成 `deploy/linux-x64/`（瘦身 patrol + 默认便携 Node `bin/node`，禁 devDeps）。  
-可选：`DINGTALK_PATROL_INCLUDE_NODE=0`、`DINGTALK_PATROL_NODE_URL`、`DINGTALK_PATROL_INCLUDE_DWS=0`（默认尝试打入 linux ELF dws；Windows 打包机需 `DINGTALK_PATROL_DWS_PATH` 指向 ELF）。  
-`dingtalk_patrol_setup` 只写 staging（含本机已验证投递凭据）；传装用 host-execution 或 SSH，目标机跑 `install.sh`。可选 `deploy.sh` 为直连 SSH helper。  
+`npm publish` 的 `files` 仅含 `dist/src` + `guides` + README/LICENSE；**不会**把 `host-patrol/`、`lib/`、`deploy/` 打进 registry。
+
+`pack:deploy` **仅 monorepo**（需要 `host-patrol/`、`lib/`、`scripts/`）。npx/registry 没有这些目录；`patrol_bundle.available=false` 属预期。默认不打便携 Node；空气间隙设 `DINGTALK_PATROL_INCLUDE_NODE=1`。可选 `DINGTALK_PATROL_NODE_URL`、`DINGTALK_PATROL_INCLUDE_DWS=0`。Windows 可从 `dingtalk-workspace-cli` 抽出 linux ELF `dws`（或设 `DINGTALK_PATROL_DWS_PATH`）。传装跟 `copy_plan`；可选 `deploy.sh` 为直连 SSH helper。  
 
-配置示例（npx）：[`mcp/dingtalk-dws-mcp/mcp.example.json`](../../../mcp/dingtalk-dws-mcp/mcp.example.json)。npm：`dingtalk-dws-mcp@1.0.2`。
+配置示例（npx）：[`mcp/dingtalk-dws-mcp/mcp.example.json`](../../../mcp/dingtalk-dws-mcp/mcp.example.json)。npm：`dingtalk-dws-mcp@1.1.0`。
 
 规格（开发者）：[RFC-0007](../../../docs/rfc/RFC-0007-dingtalk-dws-mcp.md)、[RFC-0008](../../../docs/rfc/RFC-0008-dingtalk-notify-patrol.md)。

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

@@ -1,7 +1,22 @@
 import type { AppConfig, RouteName, RouteType, TargetCandidate } from "../types.js";
+/** Persisted bind record. Both fields required. */
+export type BoundTarget = {
+    id: string;
+    name: string;
+};
+/** Unified route view for doctor / list_routes / send. Bound iff name != null. */
+export type RouteBindingView = {
+    name: string | null;
+    id: string | null;
+};
 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;
+/** Read valid bindings only. Bare strings / partial objects are invalid → omitted (unbound). No migration. */
+export declare function readBoundTargets(config: AppConfig): Partial<Record<RouteName, BoundTarget>>;
+export declare function readBoundTarget(config: AppConfig, route: RouteName): BoundTarget | null;
+export declare function writeTarget(config: AppConfig, route: RouteName, target: BoundTarget): void;
 export declare function resolveRouteTarget(config: AppConfig, route: RouteName): string;
+export declare function describeRouteBinding(config: AppConfig, route: RouteName): RouteBindingView;
+export declare function describeRoutesMap(config: AppConfig, routes: readonly RouteName[]): Record<string, RouteBindingView>;
 export declare function routeType(route: RouteName): RouteType;
+/** Internal: bound iff display name is present (same rule as API surfaces). */
 export declare function isRouteConfigured(config: AppConfig, route: RouteName): boolean;

package/dist/src/notify/bind.js

@@ -5,21 +5,47 @@ 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) {
+function parseBoundTarget(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const record = raw;
+    const id = typeof record.id === "string" ? record.id.trim() : "";
+    const name = typeof record.name === "string" ? record.name.trim() : "";
+    if (!id || !name)
+        return null;
+    return { id, name };
+}
+/** Read valid bindings only. Bare strings / partial objects are invalid → omitted (unbound). No migration. */
+export function readBoundTargets(config) {
     try {
         const parsed = JSON.parse(fs.readFileSync(config.targetsPath, "utf8"));
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
-            return parsed;
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        const out = {};
+        for (const route of ["notify_group", "notify_user"]) {
+            const bound = parseBoundTarget(parsed[route]);
+            if (bound)
+                out[route] = bound;
+        }
+        return out;
     }
     catch {
-        // first bind
+        return {};
     }
-    return {};
 }
-export function writeTarget(config, route, targetId) {
+export function readBoundTarget(config, route) {
+    return readBoundTargets(config)[route] ?? null;
+}
+export function writeTarget(config, route, target) {
+    const id = target.id.trim();
+    const name = target.name.trim();
+    if (!id || !name) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", "bind requires non-empty id and name");
+    }
     fs.mkdirSync(path.dirname(config.targetsPath), { recursive: true, mode: 0o700 });
-    const targets = readTargets(config);
-    targets[route] = targetId;
+    // Rewrite from valid bindings only — invalid on-disk slots are dropped, not upgraded.
+    const targets = readBoundTargets(config);
+    targets[route] = { id, name };
     fs.writeFileSync(config.targetsPath, `${JSON.stringify(targets, null, 2)}\n`, { mode: 0o600 });
 }
 export function resolveRouteTarget(config, route) {
@@ -29,16 +55,32 @@ export function resolveRouteTarget(config, route) {
         }
         return "webhook";
     }
-    const target = readTargets(config)[route];
+    const target = readBoundTarget(config, route);
     if (!target)
         throw new DingtalkDwsError("INVALID_ARGUMENT", `Route ${route} has no bound target`);
-    return target;
+    return target.id;
+}
+export function describeRouteBinding(config, route) {
+    if (config.adapter === "webhook") {
+        if (route !== "notify_group" || !config.webhookUrl)
+            return { name: null, id: null };
+        return { name: "webhook", id: null };
+    }
+    const bound = readBoundTarget(config, route);
+    if (!bound)
+        return { name: null, id: null };
+    return { name: bound.name, id: bound.id };
+}
+export function describeRoutesMap(config, routes) {
+    const out = {};
+    for (const route of routes)
+        out[route] = describeRouteBinding(config, route);
+    return out;
 }
 export function routeType(route) {
     return route === "notify_group" ? "group" : "user";
 }
+/** Internal: bound iff display name is present (same rule as API surfaces). */
 export function isRouteConfigured(config, route) {
-    if (config.adapter === "webhook")
-        return route === "notify_group" && Boolean(config.webhookUrl);
-    return Boolean(readTargets(config)[route]);
+    return describeRouteBinding(config, route).name != null;
 }

package/dist/src/{patrol → patrol-setup}/setup.d.ts

@@ -1,11 +1,31 @@
 import type { AppConfig, RouteName } from "../types.js";
-/** Agent-filled args (not mcp.json forms). Delivery credentials come from MCP env → env.sh. */
+declare const DELIVER_POLICIES: readonly ["always", "on_status_change", "only_statuses"];
+type DeliverPolicyKind = (typeof DELIVER_POLICIES)[number];
+declare const TERMINATION_POLICIES: readonly ["none", "status_match", "manual"];
+type TerminationPolicyKind = (typeof TERMINATION_POLICIES)[number];
+export type PatrolSetupIntent = "always" | "long_monitor" | "stop_on_critical" | "on_event";
+export type PatrolSetupDeliver = {
+    policy?: DeliverPolicyKind;
+    statuses?: string[];
+};
+export type PatrolSetupTermination = {
+    policy?: TerminationPolicyKind;
+    status?: string;
+    on?: "first" | "until";
+    terminate_on_delivery_failure?: boolean;
+};
+/** 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;
+    /** Recipe alias for Agent. Explicit deliver/termination override the alias. */
+    intent?: PatrolSetupIntent;
+    watch_path?: string;
+    deliver?: PatrolSetupDeliver;
+    termination?: PatrolSetupTermination;
     /** Soft mode: allow missing bind/bundle (tests / preview). Always stages only. */
     dry_run?: boolean;
 };
@@ -21,7 +41,8 @@ export declare function readBundleInfo(env?: NodeJS.ProcessEnv): {
 };
 /**
  * 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.
+ * Prefer copy_plan.artifact (one .tgz). Two-dir copy is fallback when tar packing fails.
  */
 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>;
+export {};

package/dist/src/patrol-setup/setup.js

@@ -0,0 +1,386 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { execFileSync } from "node:child_process";
+import { DEFAULT_PATROL_MESSAGE_BODY, DEFAULT_PATROL_MESSAGE_TITLE, } from "../notify-delivery/index.js";
+import { DingtalkDwsError } from "../errors.js";
+import { isRouteConfigured, readBoundTarget } from "../notify/bind.js";
+import { mcpPackageRoot, readPackageVersion } from "../version.js";
+const OBSERVATION_STATUSES = ["ok", "warning", "critical", "unknown"];
+const DELIVER_POLICIES = ["always", "on_status_change", "only_statuses"];
+const TERMINATION_POLICIES = ["none", "status_match", "manual"];
+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}. ` +
+                `pack:deploy is monorepo-only (clone agent-compose, cd packages/mcp/dingtalk-dws-mcp, npm run pack:deploy). ` +
+                `npx installs do not include host-patrol/ or deploy artifacts.`,
+        };
+    }
+    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)");
+}
+const INTENT_PRESETS = {
+    always: { deliver: { policy: "always" }, termination: { policy: "none" } },
+    long_monitor: {
+        deliver: { policy: "on_status_change", statuses: ["warning", "critical"] },
+        termination: { policy: "none" },
+    },
+    stop_on_critical: {
+        deliver: { policy: "always" },
+        termination: { policy: "status_match", status: "critical", on: "first" },
+    },
+    on_event: { deliver: { policy: "always" }, termination: { policy: "none" } },
+};
+function policiesFromIntent(intent) {
+    return INTENT_PRESETS[intent];
+}
+function resolvePolicies(input) {
+    const intent = input.intent ?? "always";
+    const preset = policiesFromIntent(intent);
+    return {
+        intent,
+        deliver: normalizeDeliver(input.deliver ?? preset.deliver),
+        termination: normalizeTermination(input.termination ?? preset.termination),
+    };
+}
+function writeJobArchive(options) {
+    const installSrc = path.join(options.bundleRoot, "install.sh");
+    if (!fs.existsSync(installSrc))
+        return null;
+    const packDir = fs.mkdtempSync(path.join(os.tmpdir(), "patrol-job-"));
+    try {
+        writeLf(path.join(packDir, "install.sh"), fs.readFileSync(installSrc, "utf8"), 0o755);
+        const manifest = path.join(options.bundleRoot, "manifest.json");
+        if (fs.existsSync(manifest))
+            fs.copyFileSync(manifest, path.join(packDir, "manifest.json"));
+        const runtime = path.join(options.bundleRoot, "runtime");
+        const includes_runtime = fs.existsSync(runtime);
+        if (includes_runtime)
+            fs.cpSync(runtime, path.join(packDir, "runtime"), { recursive: true });
+        fs.cpSync(options.stagingRoot, path.join(packDir, "staging"), { recursive: true });
+        fs.mkdirSync(path.dirname(options.outFile), { recursive: true });
+        if (fs.existsSync(options.outFile))
+            fs.unlinkSync(options.outFile);
+        const entries = ["install.sh", "staging"];
+        if (fs.existsSync(path.join(packDir, "manifest.json")))
+            entries.push("manifest.json");
+        if (includes_runtime)
+            entries.push("runtime");
+        const dest = options.outFile.replace(/\\/g, "/");
+        const cwd = packDir.replace(/\\/g, "/");
+        execFileSync("tar", ["-czf", dest, "-C", cwd, ...entries], { windowsHide: true });
+        return { bytes: fs.statSync(options.outFile).size, includes_runtime };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        fs.rmSync(packDir, { recursive: true, force: true });
+    }
+}
+function isObservationStatus(value) {
+    return OBSERVATION_STATUSES.includes(value);
+}
+function normalizeDeliver(input) {
+    const policy = input?.policy ?? "always";
+    if (!DELIVER_POLICIES.includes(policy)) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", "deliver.policy must be always | on_status_change | only_statuses");
+    }
+    const statuses = (input?.statuses ?? []).filter((s) => typeof s === "string" && isObservationStatus(s));
+    if (input?.statuses && input.statuses.length !== statuses.length) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", "deliver.statuses must be ok|warning|critical|unknown");
+    }
+    if (policy === "only_statuses" && statuses.length === 0) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", "deliver.statuses is required when deliver.policy is only_statuses");
+    }
+    return statuses.length ? { policy, statuses } : { policy };
+}
+function normalizeTermination(input) {
+    const policy = input?.policy ?? "none";
+    if (!TERMINATION_POLICIES.includes(policy)) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", "termination.policy must be none | status_match | manual");
+    }
+    if (policy !== "status_match") {
+        return { policy };
+    }
+    const status = input?.status;
+    if (!status || !isObservationStatus(status)) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", "termination.status must be ok|warning|critical|unknown");
+    }
+    const on = input?.on === "until" ? "until" : "first";
+    return {
+        policy,
+        status,
+        on,
+        terminate_on_delivery_failure: input?.terminate_on_delivery_failure === true,
+    };
+}
+function yamlBlockDeliver(deliver) {
+    const lines = ["deliver:", `  policy: ${deliver.policy}`];
+    if (deliver.statuses?.length) {
+        lines.push(`  statuses: [${deliver.statuses.map((s) => JSON.stringify(s)).join(", ")}]`);
+    }
+    return lines.join("\n");
+}
+function yamlBlockTermination(termination) {
+    const lines = ["termination:", `  policy: ${termination.policy}`];
+    if (termination.policy === "status_match" && termination.status) {
+        lines.push(`  status: ${termination.status}`);
+        lines.push(`  on: ${termination.on ?? "first"}`);
+        if (termination.terminate_on_delivery_failure) {
+            lines.push("  terminate_on_delivery_failure: true");
+        }
+    }
+    return lines.join("\n");
+}
+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");
+    const trigger = options.watchPath
+        ? `trigger:
+  type: event
+  watch:
+    path: ${JSON.stringify(options.watchPath)}`
+        : `cron: ${JSON.stringify(options.cron ?? "*/15 * * * *")}`;
+    return `name: ${options.name}
+${trigger}
+probe:
+  exec:
+    command: ${JSON.stringify(options.probeCommand)}
+    timeout_sec: 60
+delivery:
+${delivery.join("\n")}
+${yamlBlockDeliver(options.deliver)}
+${yamlBlockTermination(options.termination)}
+template:
+  title: ${JSON.stringify(DEFAULT_PATROL_MESSAGE_TITLE)}
+  body: |
+${body}
+`;
+}
+/**
+ * Stage offline patrol materials only. Does not SSH/scp.
+ * Prefer copy_plan.artifact (one .tgz). Two-dir copy is fallback when tar packing fails.
+ */
+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 { intent, deliver, termination } = resolvePolicies(input);
+    if (intent === "on_event" && !input.watch_path?.trim()) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", "watch_path is required for intent=on_event (host file or directory; EventTrigger uses fs.watch, not cron)");
+    }
+    const watchPath = intent === "on_event" ? input.watch_path.trim() : undefined;
+    const cron = watchPath ? undefined : (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;
+    let targetName;
+    if (deliveryType === "dws") {
+        const bound = readBoundTarget(config, route);
+        if (!bound && !input.dry_run) {
+            throw new DingtalkDwsError("INVALID_ARGUMENT", `Bind ${route} before setup`);
+        }
+        if (bound) {
+            targetName = bound.name;
+            target = route === "notify_group"
+                ? { field: "open_conversation_id", id: bound.id }
+                : { field: "user_id", id: bound.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,
+        watchPath,
+        probeCommand: probeCommand.includes("/") || probeCommand.includes("\\")
+            ? probeCommand
+            : `./probes/${path.basename(probeFile)}`,
+        deliveryType,
+        target,
+        deliver,
+        termination,
+    }));
+    writeEnvFile(envPath, config, env);
+    const artifactPath = path.join(path.dirname(stagingRoot), `${name}.tgz`);
+    const archive = bundle.available
+        ? writeJobArchive({ bundleRoot: bundle.bundle_root, stagingRoot, outFile: artifactPath })
+        : null;
+    const response = {
+        ok: true,
+        name,
+        cron,
+        route,
+        intent,
+        watch_path: watchPath,
+        trigger: watchPath ? { type: "event", watch: { path: watchPath } } : { type: "cron", cron },
+        deliver,
+        termination,
+        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: archive
+            ? `Copy one file ${artifactPath} to the host, tar -xzf, then ./install.sh ./staging. LAN hosts: local SCP. Do not send RFC1918 IPs via ACCESS.`
+            : "Copy bundle_root and staging_dir to the host, then run install.sh <staging_on_host>",
+        copy_plan: archive
+            ? {
+                artifact: artifactPath,
+                bytes: archive.bytes,
+                includes_runtime: archive.includes_runtime,
+                remote_install: "tar -xzf <job.tgz> && ./install.sh ./staging",
+            }
+            : {
+                bundle_root: bundle.bundle_root,
+                staging_dir: stagingRoot,
+                remote_install: "install.sh <staging_on_host>",
+            },
+        server_version: readPackageVersion(),
+        paths: { yaml: yamlPath, env: envPath, probe: probeFile, artifact: archive ? artifactPath : undefined },
+    };
+    if (targetName)
+        response.target_name = targetName;
+    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);
+    let next_action = null;
+    if (!info.available) {
+        next_action =
+            "Host patrol bundle missing. In this repo: npm run pack:deploy and set DINGTALK_PATROL_BUNDLE_ROOT. npx installs have no deploy artifacts — do not dry_run as a substitute for packing.";
+    }
+    else if (!info.includes_dws) {
+        next_action =
+            "Bundle has no linux dws ELF. Re-run pack:deploy on a machine with dingtalk-workspace-cli (or set DINGTALK_PATROL_DWS_PATH). Target otherwise needs system dws.";
+    }
+    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,
+        next_action,
+    };
+}

package/dist/src/prompts.js

@@ -2,12 +2,10 @@ 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):
+const PATROL_RECIPE = `Host Job Runtime (RFC-0008; 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`;
+2. Managed: search → bind if needed. Search empty (next_action=ask_user): stop and ask the user; do not guess another name.
+3. dingtalk_patrol_setup once (intent from conversation; on_event needs watch_path). Follow copy_plan. Stop — no session loop or dingtalk_send.`;
 export function listPromptDefinitions(_surface) {
     return [
         {

package/dist/src/service.d.ts

@@ -1,7 +1,7 @@
 import type { CommandRunner } from "./internal/exec.js";
 import type { AdapterKind, AppConfig, RouteName, RouteType, SendInput } from "./types.js";
 import { IdempotencyStore } from "./notify/idempotency-store.js";
-import { type PatrolSetupInput } from "./patrol/setup.js";
+import { type PatrolSetupInput } from "./patrol-setup/setup.js";
 export declare class DingtalkDwsService {
     private readonly config;
     private readonly store;

package/dist/src/service.js

@@ -4,10 +4,10 @@ import { sendWebhook, validateWebhookConfig } from "./delivery/webhook.js";
 import { DingtalkDwsError } from "./errors.js";
 import { dwsAuthLogin, dwsAuthStatus, probeDws } from "./internal/dws-auth-command.js";
 import { sendRobotMessage } from "./internal/dws-robot-command.js";
-import { candidateRef, isRouteConfigured, resolveRouteTarget, routeType, writeTarget } from "./notify/bind.js";
+import { candidateRef, describeRouteBinding, describeRoutesMap, resolveRouteTarget, routeType, writeTarget, } from "./notify/bind.js";
 import { validateSendContent } from "./notify/content.js";
 import { sha256 } from "./notify/idempotency-store.js";
-import { bundleFingerprintForDoctor, runPatrolSetup } from "./patrol/setup.js";
+import { bundleFingerprintForDoctor, runPatrolSetup } from "./patrol-setup/setup.js";
 import { readPackageVersion } from "./version.js";
 export class DingtalkDwsService {
     config;
@@ -41,12 +41,23 @@ export class DingtalkDwsService {
         const dwsReady = probe.installed && auth.authenticated === true;
         let notifyReady = false;
         let notifyMessage = this.config.adapterError ?? "Notify credentials are not configured";
+        const routeViews = this.config.adapter === "webhook"
+            ? describeRoutesMap(this.config, ["notify_group"])
+            : this.config.adapter === "dws"
+                ? describeRoutesMap(this.config, ["notify_group", "notify_user"])
+                : {};
         if (this.config.adapter === "dws") {
-            notifyReady = Boolean(this.config.clientId && this.config.clientSecret)
-                && (isRouteConfigured(this.config, "notify_group") || isRouteConfigured(this.config, "notify_user"));
-            notifyMessage = notifyReady
-                ? "Managed notify is ready"
-                : "Configure robot credentials and bind at least one route";
+            const credsOk = Boolean(this.config.clientId && this.config.clientSecret);
+            const routeOk = Object.values(routeViews).some((view) => view.name != null);
+            notifyReady = credsOk && routeOk;
+            if (!credsOk)
+                notifyMessage = "Configure robot credentials and bind at least one route";
+            else if (!routeOk) {
+                notifyMessage =
+                    "Bind notify_group or notify_user with {id,name}; call list_routes to verify the group/user name";
+            }
+            else
+                notifyMessage = "Managed notify is ready";
         }
         else if (this.config.adapter === "webhook") {
             const validation = validateWebhookConfig(this.config);
@@ -88,17 +99,9 @@ export class DingtalkDwsService {
             },
             notify: {
                 adapter: this.config.adapter,
-                credentials_configured: this.config.adapter === "webhook"
-                    ? Boolean(this.config.webhookUrl)
-                    : Boolean(this.config.clientId && this.config.clientSecret),
                 ready: notifyReady,
                 message: notifyMessage,
-                routes: this.config.adapter === "webhook"
-                    ? { notify_group: { configured: isRouteConfigured(this.config, "notify_group") } }
-                    : {
-                        notify_group: { configured: isRouteConfigured(this.config, "notify_group") },
-                        notify_user: { configured: isRouteConfigured(this.config, "notify_user") },
-                    },
+                routes: routeViews,
             },
             next_action,
         };
@@ -128,15 +131,17 @@ export class DingtalkDwsService {
         const names = this.config.adapter === "webhook"
             ? ["notify_group"]
             : ["notify_group", "notify_user"];
-        const routes = names.map((name) => ({
-            name,
-            type: routeType(name),
-            configured: isRouteConfigured(this.config, name),
-            description: name === "notify_group" ? "Notify a DingTalk group" : "Notify a DingTalk user",
-        }));
         return {
             adapter: this.config.adapter,
-            routes,
+            routes: names.map((route) => {
+                const binding = describeRouteBinding(this.config, route);
+                return {
+                    route,
+                    type: routeType(route),
+                    name: binding.name,
+                    id: binding.id,
+                };
+            }),
         };
     }
     /** Adapter used to shape the public MCP tool surface. */
@@ -153,12 +158,22 @@ export class DingtalkDwsService {
         for (const type of types) {
             candidates.push(...await searchTargets(this.config, type, input.query, input.limit ?? 10, this.runner, this.env));
         }
+        const mapped = candidates.map((candidate) => ({
+            type: candidate.type,
+            name: candidate.name,
+            candidate_ref: candidateRef(candidate),
+        }));
         return {
-            candidates: candidates.map((candidate) => ({
-                type: candidate.type,
-                name: candidate.name,
-                candidate_ref: candidateRef(candidate),
-            })),
+            query: input.query,
+            type: input.type ?? "all",
+            candidates: mapped,
+            next_action: mapped.length === 0 ? "ask_user" : "bind",
+            ...(mapped.length === 0
+                ? {
+                    message: `No DingTalk target matched ${JSON.stringify(input.query)}. ` +
+                        "Ask the user for the exact display name shown in DingTalk. Do not search a guessed name or bind a similar candidate.",
+                }
+                : {}),
         };
     }
     async configureRouteTarget(input) {
@@ -172,21 +187,29 @@ export class DingtalkDwsService {
         for (const type of types) {
             candidates.push(...await searchTargets(this.config, type, input.query, input.candidate_ref ? 20 : 2, this.runner, this.env));
         }
+        if (candidates.length === 0) {
+            throw new DingtalkDwsError("INVALID_ARGUMENT", `No DingTalk target matched ${JSON.stringify(input.query)}. Ask the user for the exact display name. Do not bind a similar candidate.`);
+        }
         const candidate = input.candidate_ref
             ? candidates.find((item) => candidateRef(item) === input.candidate_ref)
             : candidates.length === 1 ? candidates[0] : undefined;
         if (!candidate) {
-            throw new DingtalkDwsError("INVALID_ARGUMENT", "Zero or multiple candidates; confirm one candidate_ref before binding");
+            throw new DingtalkDwsError("INVALID_ARGUMENT", `Multiple matches for ${JSON.stringify(input.query)}; pass candidate_ref after the user picks one. Do not guess.`);
         }
         const route = input.route ?? (candidate.type === "group" ? "notify_group" : "notify_user");
         if (routeType(route) !== candidate.type) {
             throw new DingtalkDwsError("INVALID_ARGUMENT", "candidate type does not match route");
         }
-        writeTarget(this.config, route, candidate.target_id);
+        const displayName = candidate.name.trim();
+        if (!displayName) {
+            throw new DingtalkDwsError("INVALID_ARGUMENT", "candidate name is required to bind a transparent route");
+        }
+        writeTarget(this.config, route, { id: candidate.target_id, name: displayName });
         return {
             route,
             type: candidate.type,
-            name: candidate.name,
+            name: displayName,
+            id: candidate.target_id,
             candidate_ref: candidateRef(candidate),
         };
     }
@@ -198,6 +221,7 @@ export class DingtalkDwsService {
         validateSendContent(input, this.config);
         const title = input.title.trim();
         const content = input.content.trim();
+        const target = describeRouteBinding(this.config, input.route);
         if (input.dedupe_key) {
             const key = sha256(`${input.route}\n${input.dedupe_key}`);
             const claim = this.store.claim(key, Date.now(), this.config.suppressionWindowSeconds);
@@ -205,6 +229,7 @@ export class DingtalkDwsService {
                 return {
                     status: "suppressed",
                     route: input.route,
+                    target: { name: target.name, id: target.id },
                     message_id: claim.messageId ?? null,
                     deduplicated: true,
                 };
@@ -222,6 +247,7 @@ export class DingtalkDwsService {
                 return {
                     status: "sent",
                     route: input.route,
+                    target: { name: target.name, id: target.id },
                     message_id: result.messageId ?? null,
                     deduplicated: false,
                     sent_at: new Date().toISOString(),
@@ -240,6 +266,7 @@ export class DingtalkDwsService {
         return {
             status: "sent",
             route: input.route,
+            target: { name: target.name, id: target.id },
             message_id: result.messageId ?? null,
             deduplicated: false,
             sent_at: new Date().toISOString(),

package/dist/src/tools/registry.js

@@ -16,7 +16,7 @@ export function buildInstructions(surface) {
     const lines = [
         "DingTalk robot notify + dws readiness (Agent surface of the dws ecosystem). Office stays on local dws.",
         "Office via local dws: before following upstream Skill recipes, read this server's MCP Resources overlays when they apply.",
-        "Constraint: recurring/host patrol must not use session loops or repeated dingtalk_send — Agent derives host/cron/probe from conversation, calls dingtalk_patrol_setup once (stages bundle paths + delivery credentials), copies to host via host-execution or SSH, runs install.sh on the host, then stops. MCP env holds credentials only. Do not download Node in-session.",
+        "Constraint: host Job Runtime (RFC-0008) must not use session loops or repeated dingtalk_send — Agent calls dingtalk_patrol_setup once, follows copy_plan, then stops. Do not download Node in-session. dingtalk_send is one-shot on this machine only. MCP env holds credentials only.",
         "Call dingtalk_doctor first; connected ≠ ready.",
     ];
     if (surface.adapter === null) {
@@ -26,7 +26,7 @@ export function buildInstructions(surface) {
         lines.push("Webhook tools: doctor + send (notify_group only).");
     }
     else {
-        lines.push("Managed tools: search → bind → send. Bind targets are for this server only.");
+        lines.push("Managed tools: search → bind → send. Bind targets are for this server only. Empty search (next_action=ask_user): tell the user and stop — do not retry with a guessed name or bind a similar person.");
     }
     lines.push("Never put credentials or secrets in message content.");
     if (surface.authTools) {
@@ -58,7 +58,7 @@ export function createToolDefinitions(surface) {
     if (surface.directoryTools) {
         tools.push({
             name: "dingtalk_search_targets",
-            description: "Find groups/users by display name; returns opaque candidate_ref for bind.",
+            description: "Find groups/users by the name the user gave. Returns candidate_ref for bind. If candidates is empty, next_action is ask_user: report that to the user and stop. Do not invent another query or bind a similarly named person.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -72,7 +72,7 @@ export function createToolDefinitions(surface) {
             annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         }, {
             name: "dingtalk_configure_route_target",
-            description: "Bind one search result to notify_group or notify_user for later send.",
+            description: "Bind one search result to notify_group or notify_user. Use candidate_ref from search. If search was empty, do not call this with a different guessed query.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -90,7 +90,7 @@ export function createToolDefinitions(surface) {
     if (surface.listRoutes) {
         tools.push({
             name: "dingtalk_list_routes",
-            description: "List whether notify_group / notify_user are bound.",
+            description: "List notify_group / notify_user bindings with target name and id so you can verify the destination before send.",
             inputSchema: emptySchema,
             annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
         });
@@ -119,7 +119,7 @@ export function createToolDefinitions(surface) {
     // Always available: stage host patrol materials (Agent transfers + remote install).
     tools.push({
         name: "dingtalk_patrol_setup",
-        description: "Stage offline patrol materials only (patrol.yaml, env.sh with local delivery credentials, probe). Does not SSH. Agent fills name/cron/probe from conversation; prefer bound notify target (omit route). Then copy bundle_root + staging_dir to the host (host-execution or SSH) and run install.sh there. Call once for staging, finish install, then stop. Never returns secrets.",
+        description: "Stage host Job Runtime materials only. Does not SSH. Prefer intent=always|long_monitor|stop_on_critical|on_event. on_event needs watch_path (file/dir on the host; fs.watch, not cron). Follow copy_plan. Call once, then stop. Not dingtalk_send. Never returns secrets.",
         inputSchema: {
             type: "object",
             properties: {
@@ -128,6 +128,36 @@ export function createToolDefinitions(surface) {
                 route: { type: "string", enum: ["notify_group", "notify_user"] },
                 probe_command: { type: "string" },
                 probe_script: { type: "string" },
+                intent: {
+                    type: "string",
+                    enum: ["always", "long_monitor", "stop_on_critical", "on_event"],
+                    description: "Recipe alias. on_event requires watch_path (EventTrigger). Explicit deliver/termination override this.",
+                },
+                watch_path: {
+                    type: "string",
+                    description: "Host file or directory to watch when intent=on_event. Not a cron interval.",
+                },
+                deliver: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        policy: { type: "string", enum: ["always", "on_status_change", "only_statuses"] },
+                        statuses: {
+                            type: "array",
+                            items: { type: "string", enum: ["ok", "warning", "critical", "unknown"] },
+                        },
+                    },
+                },
+                termination: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        policy: { type: "string", enum: ["none", "status_match", "manual"] },
+                        status: { type: "string", enum: ["ok", "warning", "critical", "unknown"] },
+                        on: { type: "string", enum: ["first", "until"] },
+                        terminate_on_delivery_failure: { type: "boolean" },
+                    },
+                },
                 dry_run: { type: "boolean", description: "Allow missing bind/bundle (preview/tests); still writes staging" },
             },
             required: ["name"],
@@ -147,6 +177,70 @@ function requireNonEmptyString(input, key) {
     }
     return value.trim();
 }
+function asObject(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new DingtalkDwsError("INVALID_ARGUMENT", `${key} must be an object`);
+    }
+    return value;
+}
+function parseSetupIntent(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === "always" || value === "long_monitor" || value === "stop_on_critical" || value === "on_event") {
+        return value;
+    }
+    throw new DingtalkDwsError("INVALID_ARGUMENT", "intent must be always | long_monitor | stop_on_critical | on_event");
+}
+function parseSetupDeliver(value) {
+    if (value === undefined)
+        return undefined;
+    const rec = asObject(value, "deliver");
+    const out = {};
+    if (rec.policy !== undefined) {
+        if (rec.policy !== "always" && rec.policy !== "on_status_change" && rec.policy !== "only_statuses") {
+            throw new DingtalkDwsError("INVALID_ARGUMENT", "deliver.policy must be always | on_status_change | only_statuses");
+        }
+        out.policy = rec.policy;
+    }
+    if (rec.statuses !== undefined) {
+        if (!Array.isArray(rec.statuses) || rec.statuses.some((s) => typeof s !== "string")) {
+            throw new DingtalkDwsError("INVALID_ARGUMENT", "deliver.statuses must be a string array");
+        }
+        out.statuses = rec.statuses;
+    }
+    return out;
+}
+function parseSetupTermination(value) {
+    if (value === undefined)
+        return undefined;
+    const rec = asObject(value, "termination");
+    const out = {};
+    if (rec.policy !== undefined) {
+        if (rec.policy !== "none" && rec.policy !== "status_match" && rec.policy !== "manual") {
+            throw new DingtalkDwsError("INVALID_ARGUMENT", "termination.policy must be none | status_match | manual");
+        }
+        out.policy = rec.policy;
+    }
+    if (rec.status !== undefined) {
+        if (typeof rec.status !== "string") {
+            throw new DingtalkDwsError("INVALID_ARGUMENT", "termination.status must be a string");
+        }
+        out.status = rec.status;
+    }
+    if (rec.on !== undefined) {
+        if (rec.on !== "first" && rec.on !== "until") {
+            throw new DingtalkDwsError("INVALID_ARGUMENT", "termination.on must be first or until");
+        }
+        out.on = rec.on;
+    }
+    if (rec.terminate_on_delivery_failure !== undefined) {
+        if (typeof rec.terminate_on_delivery_failure !== "boolean") {
+            throw new DingtalkDwsError("INVALID_ARGUMENT", "termination.terminate_on_delivery_failure must be a boolean");
+        }
+        out.terminate_on_delivery_failure = rec.terminate_on_delivery_failure;
+    }
+    return out;
+}
 function optionalPositiveInt(value, key) {
     if (value === undefined)
         return undefined;
@@ -259,6 +353,10 @@ export async function callTool(service, name, args, surface) {
                     : parseRouteName(input.route, ["notify_group", "notify_user"]),
                 probe_command: optionalString("probe_command"),
                 probe_script: optionalString("probe_script"),
+                intent: parseSetupIntent(input.intent),
+                watch_path: optionalString("watch_path"),
+                deliver: parseSetupDeliver(input.deliver),
+                termination: parseSetupTermination(input.termination),
                 dry_run: optionalBool("dry_run"),
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dingtalk-dws-mcp",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "DingTalk robot notification MCP with dws readiness handshake",
   "license": "Apache-2.0",
   "type": "module",
@@ -18,14 +18,18 @@
     "dingtalk-dws-mcp": "dist/src/index.js"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "sync:delivery": "node scripts/sync-notify-delivery.mjs",
+    "build": "npm run sync:delivery && tsc -p tsconfig.json",
     "prepack": "npm run build",
-    "prepublishOnly": "npm run build && npm test",
+    "prepublishOnly": "npm run build && npm run test:mcp",
     "start": "node dist/src/index.js",
     "pack:deploy": "node scripts/pack-deploy.mjs",
-    "test": "npm run build && vitest run",
+    "test:mcp": "npm run build && vitest run",
+    "test:lib": "npm --prefix lib/notify-delivery test",
+    "test:host-patrol": "npm --prefix host-patrol test",
+    "test": "npm run test:mcp && npm run test:lib && npm run test:host-patrol",
     "test:watch": "vitest",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "typecheck": "npm run sync:delivery && tsc -p tsconfig.json --noEmit"
   },
   "keywords": [
     "mcp",

package/dist/src/patrol/setup.js

@@ -1,213 +0,0 @@
-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 "../notify-delivery/index.js";
-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,
-    };
-}