@co0ontty/wand 4.102.0 → 4.103.0

package/dist/dingtalk-auth.js

@@ -0,0 +1,127 @@
+import { randomUUID } from "node:crypto";
+import { array, boundedFetch, DingTalkError, object, string } from "./dingtalk-dws.js";
+/** Structured device OAuth, not scraping localized CLI stderr. Codes stay in memory and are exchanged over stdin. */
+export class DingTalkAuth {
+    dws;
+    request;
+    attempts = new Map();
+    constructor(dws, request = boundedFetch) {
+        this.dws = dws;
+        this.request = request;
+    }
+    async accounts() {
+        const result = await this.dws.call(["profile", "list"]);
+        return array(result.profiles ?? result.items ?? result.data).flatMap(raw => {
+            const p = object(raw), id = string(p.profile ?? p.id), parts = id.split(":");
+            const corpId = string(p.corpId) || parts[0], userId = string(p.userId) || parts[1];
+            if (!corpId || !userId || p.authenticated === false)
+                return [];
+            return [{ id: `${corpId}:${userId}`, corpId, userId, name: string(p.userName ?? p.name) || userId, corpName: string(p.corpName) || corpId }];
+        });
+    }
+    async json(url, init) { return object(JSON.parse((await this.request(url, { ...init, redirect: "error" })).toString())); }
+    async begin() {
+        for (const a of this.attempts.values())
+            if (a.state === "waiting" || a.state === "exchanging")
+                return this.public(a);
+        this.attempts.clear();
+        const client = await this.json("https://mcp.dingtalk.com/cli/clientId", {});
+        const clientId = string(client.result);
+        if (client.success !== true || !clientId)
+            throw new DingTalkError("auth_unavailable", "无法取得钉钉授权应用信息。");
+        const raw = await this.json("https://login.dingtalk.com/oauth2/device/code.json", {
+            method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({ client_id: clientId, scope: "openid corpid" }).toString(),
+        });
+        const data = object(raw.result);
+        const deviceCode = string(data.deviceCode), flowId = string(data.flowId);
+        const url = string(data.verificationUriComplete ?? data.verificationUri);
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            throw new DingTalkError("auth_url", "钉钉授权链接无效。");
+        }
+        if (parsed.protocol !== "https:" || !["login.dingtalk.com", "open-dev.dingtalk.com"].includes(parsed.hostname) || parsed.username || parsed.password || parsed.port)
+            throw new DingTalkError("auth_url", "钉钉返回了未受信任的授权链接。");
+        if (raw.success !== true || !deviceCode || !string(data.userCode))
+            throw new DingTalkError("auth_invalid", "钉钉设备授权响应无效。");
+        const expires = Math.min(600, Math.max(30, Number(data.expiresIn) || 600));
+        const attempt = { id: randomUUID(), state: "waiting", url, userCode: data.userCode,
+            expiresAt: new Date(Date.now() + expires * 1000).toISOString(), abort: new AbortController() };
+        this.attempts.set(attempt.id, attempt);
+        void this.poll(attempt, clientId, deviceCode, flowId, Math.min(30, Math.max(2, Number(data.interval) || 2)));
+        return this.public(attempt);
+    }
+    get(id) { const value = this.attempts.get(id); if (!value)
+        throw new DingTalkError("not_found", "授权会话不存在或已失效，请重新授权。"); return this.public(value); }
+    cancel(id) {
+        const value = this.attempts.get(id);
+        if (!value)
+            throw new DingTalkError("not_found", "授权会话已失效。");
+        if (value.state === "waiting") {
+            value.state = "cancelled";
+            value.url = "";
+            value.userCode = "";
+            value.abort.abort();
+        }
+        // A one-time code already handed to DWS cannot be promised revoked. Report the real phase.
+        return this.public(value);
+    }
+    public(a) { return { id: a.id, state: a.state, url: a.state === "waiting" ? a.url : undefined, userCode: a.state === "waiting" ? a.userCode : undefined, expiresAt: a.expiresAt, error: a.error, account: a.account }; }
+    async poll(a, clientId, deviceCode, flowId, interval) {
+        try {
+            while (a.state === "waiting" && Date.now() < Date.parse(a.expiresAt)) {
+                await new Promise((resolve, reject) => {
+                    const cancelled = () => { clearTimeout(timer); reject(new Error("cancelled")); };
+                    const timer = setTimeout(() => { a.abort.signal.removeEventListener("abort", cancelled); resolve(); }, interval * 1000);
+                    timer.unref?.();
+                    a.abort.signal.addEventListener("abort", cancelled, { once: true });
+                });
+                if (a.abort.signal.aborted)
+                    return;
+                const response = flowId
+                    ? await this.json(`https://mcp.dingtalk.com/cli/oauth/device/poll?flowId=${encodeURIComponent(flowId)}`, { signal: a.abort.signal })
+                    : await this.json("https://login.dingtalk.com/oauth2/device/token.json", { method: "POST", signal: a.abort.signal,
+                        headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ grant_type: "urn:ietf:params:oauth:grant-type:device_code", device_code: deviceCode, client_id: clientId }).toString() });
+                const data = object(response.data ?? response.result);
+                if (["REJECTED", "EXPIRED", "CANCELLED"].includes(data.status))
+                    throw new DingTalkError("auth_rejected", "授权被取消、拒绝或已过期，请重新授权。");
+                const code = string(data.authCode);
+                if (!code)
+                    continue;
+                if (a.abort.signal.aborted || a.state !== "waiting")
+                    return;
+                a.state = "exchanging";
+                a.url = "";
+                a.userCode = "";
+                const result = await this.dws.call(["auth", "exchange", "--code-stdin", "--client-id", clientId], { input: code });
+                const corpId = string(result.corpId), userId = string(result.userId);
+                if (!corpId || !userId)
+                    throw new DingTalkError("identity", "钉钉未返回可验证的组织和用户身份。");
+                if (a.abort.signal.aborted || a.state !== "exchanging")
+                    return;
+                a.account = { id: `${corpId}:${userId}`, corpId, userId, name: userId, corpName: corpId };
+                a.state = "connected";
+                a.url = "";
+                a.userCode = "";
+                return;
+            }
+            if (a.state === "waiting")
+                throw new DingTalkError("expired", "授权已过期，请重新授权。");
+        }
+        catch (error) {
+            if (a.state !== "waiting" && a.state !== "exchanging")
+                return;
+            a.state = "failed";
+            a.url = "";
+            a.userCode = "";
+            a.error = error instanceof DingTalkError ? error.message : "授权未完成，请重试；不会输出或保存授权码。";
+        }
+    }
+    dispose() { for (const a of this.attempts.values()) {
+        a.state = "cancelled";
+        a.abort.abort();
+    } this.attempts.clear(); }
+}

package/dist/dingtalk-dws.d.ts

@@ -0,0 +1,45 @@
+export declare class DingTalkError extends Error {
+    readonly code: string;
+    readonly unknownDelivery: boolean;
+    readonly httpStatus?: number | undefined;
+    constructor(code: string, message: string, unknownDelivery?: boolean, httpStatus?: number | undefined);
+}
+export declare const object: (v: unknown) => Record<string, any>;
+export declare const string: (v: unknown) => string;
+export declare const array: (v: unknown) => any[];
+/** The CLI's composite helpers wrap JSON in MCP text content. Never return raw envelopes/errors to a client. */
+export declare function dwsPayload(value: unknown): Record<string, any>;
+export interface DwsTransport {
+    call(args: string[], options?: {
+        input?: string;
+        write?: boolean;
+        timeoutMs?: number;
+    }): Promise<Record<string, any>>;
+    stream(args: string[], onLine: (line: string) => void, onEnd: () => void, onReady?: () => void): {
+        close(): void;
+    };
+}
+export declare class DwsClient implements DwsTransport {
+    private readonly directory;
+    private readonly configuredBinary;
+    private children;
+    private closed;
+    private installation;
+    readonly configDir: string;
+    constructor(directory: string, configuredBinary?: string | undefined);
+    private get binary();
+    private child;
+    call(args: string[], options?: {
+        input?: string;
+        write?: boolean;
+        timeoutMs?: number;
+    }): Promise<Record<string, any>>;
+    stream(args: string[], onLine: (line: string) => void, onEnd: () => void, onReady?: () => void): {
+        close(): void;
+    };
+    dispose(): void;
+    /** Explicit admin action. Pinned release + checksum, private executable; never execute an install script. */
+    install(): Promise<void>;
+    private installPinned;
+}
+export declare function boundedFetch(url: string, init?: RequestInit, limit?: number): Promise<Buffer>;

package/dist/dingtalk-dws.js

@@ -0,0 +1,240 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, existsSync, chmodSync, writeFileSync, renameSync } from "node:fs";
+import { join, isAbsolute } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { gunzipSync } from "node:zlib";
+import { buildChildEnv } from "./env-utils.js";
+export class DingTalkError extends Error {
+    code;
+    unknownDelivery;
+    httpStatus;
+    constructor(code, message, unknownDelivery = false, httpStatus) {
+        super(message);
+        this.code = code;
+        this.unknownDelivery = unknownDelivery;
+        this.httpStatus = httpStatus;
+    }
+}
+export const object = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+export const string = (v) => typeof v === "string" ? v : "";
+export const array = (v) => Array.isArray(v) ? v : [];
+/** The CLI's composite helpers wrap JSON in MCP text content. Never return raw envelopes/errors to a client. */
+export function dwsPayload(value) {
+    const envelope = (v) => Array.isArray(v) ? { items: v } : object(v);
+    let node = envelope(value);
+    for (let i = 0; i < 12; i++) {
+        if (node.ok === false || node.success === false || node.isError === true || node.error) {
+            throw new DingTalkError("provider_rejected", "钉钉拒绝了操作，请核对账号权限与当前资源状态。");
+        }
+        if (node.response) {
+            node = envelope(node.response);
+            continue;
+        }
+        const text = array(node.content).find(x => x?.type === "text")?.text;
+        if (typeof text === "string") {
+            try {
+                node = envelope(JSON.parse(text));
+                continue;
+            }
+            catch (error) {
+                if (error instanceof DingTalkError)
+                    throw error;
+                throw new DingTalkError("invalid_response", "钉钉未返回可验证的结构化结果。");
+            }
+        }
+        const key = node.data && !Array.isArray(node.data) ? "data" : node.result && !Array.isArray(node.result) ? "result" : null;
+        if (key) {
+            const { [key]: inner, ...rest } = node;
+            node = { ...rest, ...object(inner) };
+            continue;
+        }
+        return node;
+    }
+    throw new DingTalkError("invalid_response", "钉钉响应层级异常。");
+}
+export class DwsClient {
+    directory;
+    configuredBinary;
+    children = new Set();
+    closed = false;
+    installation;
+    configDir;
+    constructor(directory, configuredBinary = process.env.WAND_DWS_BINARY) {
+        this.directory = directory;
+        this.configuredBinary = configuredBinary;
+        this.configDir = join(directory, "dingtalk", "dws");
+    }
+    get binary() {
+        if (this.configuredBinary) {
+            if (!isAbsolute(this.configuredBinary))
+                throw new DingTalkError("invalid_binary", "WAND_DWS_BINARY 必须是受信任的绝对路径。");
+            return this.configuredBinary;
+        }
+        const local = join(this.directory, "dingtalk", "bin", process.platform === "win32" ? "dws.exe" : "dws");
+        return existsSync(local) ? local : "dws";
+    }
+    child(args) {
+        // Atomic DWS leaves support @file expansion. Never grant that capability to external values.
+        // The unified chat shortcut instead has an explicit --body-stdin / --text - literal-body contract.
+        if (args.some(value => value.startsWith("@")))
+            throw new DingTalkError("literal_argument", "钉钉参数包含文件展开语法，已拒绝；消息正文应通过受限标准输入发送。");
+        if (this.closed)
+            throw new DingTalkError("closed", "钉钉连接器已关闭。");
+        mkdirSync(this.configDir, { recursive: true, mode: 0o700 });
+        // No shell; no HTTP-provided executable, env, path, token or command. Each business method owns its argv.
+        const child = spawn(this.binary, args, { env: buildChildEnv(false, { DWS_CONFIG_DIR: this.configDir }), stdio: "pipe" });
+        this.children.add(child);
+        child.once("close", () => this.children.delete(child));
+        return child;
+    }
+    async call(args, options = {}) {
+        const child = this.child([...args, "--format", "json"]);
+        return new Promise((resolve, reject) => {
+            let output = "", settled = false;
+            const fail = (code, message, unknownDelivery = options.write ?? false) => { if (!settled) {
+                settled = true;
+                reject(new DingTalkError(code, message, unknownDelivery));
+            } };
+            const timer = setTimeout(() => { fail("timeout", "钉钉操作超时，送达状态需核实；不会自动重做。"); child.kill("SIGTERM"); }, options.timeoutMs ?? 30_000);
+            timer.unref?.();
+            child.stdout.on("data", chunk => { output += chunk.toString(); if (Buffer.byteLength(output) > 2 * 1024 * 1024) {
+                fail("oversize", "钉钉响应超过安全大小。");
+                child.kill("SIGTERM");
+            } });
+            child.stderr.resume(); // May contain secrets: neither log, echo nor persist it.
+            child.once("error", () => { clearTimeout(timer); fail("unavailable", "DWS 不可用，请先安装连接器依赖。", false); });
+            child.once("close", code => {
+                clearTimeout(timer);
+                if (settled)
+                    return;
+                try {
+                    if (code !== 0)
+                        throw new DingTalkError("cli_failed", "DWS 操作未确认，请检查授权、权限和资源状态。", options.write);
+                    const result = dwsPayload(JSON.parse(output));
+                    settled = true;
+                    resolve(result);
+                }
+                catch (error) {
+                    settled = true;
+                    reject(error instanceof DingTalkError ? new DingTalkError(error.code, error.message, error.unknownDelivery || (!!options.write && error.code === "provider_rejected"), error.httpStatus) : new DingTalkError("invalid_response", "DWS 响应无效，操作状态需核实。", options.write));
+                }
+            });
+            child.stdin.end(options.input);
+        });
+    }
+    stream(args, onLine, onEnd, onReady) {
+        const child = this.child(args);
+        let pending = "", diagnostic = "", ended = false;
+        const end = () => { if (!ended) {
+            ended = true;
+            onEnd();
+        } };
+        child.on("error", end);
+        child.on("close", end);
+        child.stderr.on("data", chunk => {
+            diagnostic = (diagnostic + chunk.toString()).slice(-16_384);
+            let newline;
+            while ((newline = diagnostic.indexOf("\n")) >= 0) {
+                const line = diagnostic.slice(0, newline);
+                diagnostic = diagnostic.slice(newline + 1);
+                // DWS documents this exact machine contract. Other diagnostic text is discarded, never logged.
+                if (line.startsWith("[event] ready "))
+                    onReady?.();
+            }
+        });
+        child.stdout.on("data", chunk => {
+            pending += chunk.toString();
+            if (Buffer.byteLength(pending) > 1024 * 1024) {
+                child.kill("SIGTERM");
+                end();
+                return;
+            }
+            let newline;
+            while ((newline = pending.indexOf("\n")) >= 0) {
+                const line = pending.slice(0, newline);
+                pending = pending.slice(newline + 1);
+                if (line.trim())
+                    onLine(line);
+            }
+        });
+        // Keep stdin open: DWS treats EOF as a graceful unsubscribe.
+        return { close() { child.stdin.end(); child.kill("SIGTERM"); } };
+    }
+    dispose() { this.closed = true; for (const child of this.children) {
+        child.stdin.end();
+        child.kill("SIGTERM");
+    } this.children.clear(); }
+    /** Explicit admin action. Pinned release + checksum, private executable; never execute an install script. */
+    install() {
+        if (this.installation)
+            return this.installation;
+        const work = this.installPinned();
+        this.installation = work;
+        void work.finally(() => { if (this.installation === work)
+            this.installation = undefined; }).catch(() => { });
+        return work;
+    }
+    async installPinned() {
+        if (!["darwin", "linux"].includes(process.platform) || !["arm64", "x64"].includes(process.arch))
+            throw new DingTalkError("unsupported_platform", "此系统暂不支持自动安装 DWS，请配置受信任的可执行文件。");
+        const name = `dws-${process.platform}-${process.arch === "x64" ? "amd64" : "arm64"}.tar.gz`;
+        const base = "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.65/";
+        const checks = await boundedFetch(base + "checksums.txt", {}, 64 * 1024);
+        const archive = await boundedFetch(base + name, {}, 32 * 1024 * 1024);
+        const expected = checks.toString().split("\n").find(line => line.trim().split(/\s+/).at(-1) === name)?.split(/\s+/)[0];
+        if (!expected || createHash("sha256").update(archive).digest("hex") !== expected)
+            throw new DingTalkError("checksum", "DWS 下载校验失败，未安装。");
+        const tar = gunzipSync(archive, { maxOutputLength: 96 * 1024 * 1024 });
+        let executable;
+        for (let at = 0; at + 512 <= tar.length;) {
+            const header = tar.subarray(at, at + 512);
+            const filename = header.subarray(0, 100).toString().replace(/\0.*$/, "");
+            if (!filename)
+                break;
+            const size = Number.parseInt(header.subarray(124, 136).toString().replace(/\0.*$/, "").trim(), 8);
+            if (!Number.isSafeInteger(size) || size < 0 || at + 512 + size > tar.length)
+                throw new DingTalkError("archive", "DWS 安装包格式无效。");
+            if (filename.split("/").at(-1) === "dws" && (header[156] === 0 || header[156] === 48)) {
+                if (executable)
+                    throw new DingTalkError("archive", "DWS 安装包包含重复程序。");
+                executable = tar.subarray(at + 512, at + 512 + size);
+            }
+            at += 512 + Math.ceil(size / 512) * 512;
+        }
+        if (!executable?.length)
+            throw new DingTalkError("archive", "安装包中缺少 DWS。");
+        const bin = join(this.directory, "dingtalk", "bin");
+        mkdirSync(bin, { recursive: true, mode: 0o700 });
+        const staged = join(bin, `.dws-${randomUUID()}`);
+        writeFileSync(staged, executable, { mode: 0o700 });
+        chmodSync(staged, 0o700);
+        renameSync(staged, join(bin, "dws"));
+    }
+}
+export async function boundedFetch(url, init = {}, limit = 1024 * 1024) {
+    const timeout = AbortSignal.timeout(30_000);
+    const response = await fetch(url, { ...init, signal: init.signal ? AbortSignal.any([init.signal, timeout]) : timeout });
+    if (!response.ok || !response.body) {
+        await response.body?.cancel();
+        throw new DingTalkError("http_failed", "钉钉网络请求失败，请稍后核对状态。", false, response.status);
+    }
+    const chunks = [];
+    let size = 0;
+    const reader = response.body.getReader();
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            size += next.value.length;
+            if (size > limit)
+                throw new DingTalkError("oversize", "远端响应超过安全大小。");
+            chunks.push(next.value);
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks);
+}

package/dist/dingtalk-service.d.ts

@@ -0,0 +1,100 @@
+import type { WandStorage } from "./storage.js";
+import type { WandConfig, ProcessEvent, SessionSnapshot } from "./types.js";
+import type { StructuredSessionManager } from "./structured-session-manager.js";
+import { type ConversationReceipt } from "./conversation-types.js";
+import { type DwsTransport } from "./dingtalk-dws.js";
+import { DingTalkAuth } from "./dingtalk-auth.js";
+import { DingTalkRobotStream } from "./dingtalk-stream.js";
+import type { DingTalkBinding, DingTalkExternalConversation, DingTalkGroup, DingTalkJob, DingTalkPlan, DingTalkStatus } from "./dingtalk-types.js";
+export declare const dingTalkId: (...parts: string[]) => string;
+/** Only explicit final assistant text is exported. No transcript, thoughts, tool rows or diagnostics. */
+export declare function dingTalkFinalText(session: SessionSnapshot): string | null;
+export declare class DingTalkService {
+    private readonly deps;
+    readonly auth: DingTalkAuth;
+    private readonly discovered;
+    private readonly robotLocks;
+    private readonly robotStreams;
+    private readonly groupStreams;
+    private readonly busyRuns;
+    private deliveryActive;
+    private deliveryPumping;
+    private deliveryHalted;
+    private readonly reconnects;
+    private readonly reconnectTimers;
+    private disposed;
+    constructor(deps: {
+        storage: WandStorage;
+        dws: DwsTransport;
+        config: WandConfig;
+        structured: Pick<StructuredSessionManager, "createSession" | "sendMessage" | "get"> & {
+            stop?(id: string): unknown;
+        };
+        changed(): void;
+        robotStream?: (credentials: {
+            clientId: string;
+            clientSecret: string;
+        }, receive: (data: Record<string, any>) => Promise<void>, state: (connected: boolean) => void) => DingTalkRobotStream;
+    });
+    private get s();
+    private list;
+    private save;
+    private bindings;
+    private groups;
+    private robots;
+    private account;
+    private call;
+    status(): Promise<DingTalkStatus>;
+    discover(accountId: string, cursor?: string): Promise<{
+        groups: {
+            id: string;
+            name: string;
+            memberCount: any;
+        }[];
+        nextCursor: string;
+        complete: boolean;
+    }>;
+    private assertConfigurationCapacity;
+    plan(input: {
+        accountId: unknown;
+        groupIds: unknown;
+        employeeIds: unknown;
+        excluded?: unknown;
+        robotNames?: unknown;
+        candidateIndices?: unknown;
+    }): Promise<DingTalkPlan>;
+    connect(planId: string, confirmed: boolean): Promise<DingTalkJob>;
+    private ensureMirror;
+    metadata(group: DingTalkGroup): DingTalkExternalConversation;
+    groupForConversation(id: string): DingTalkGroup | undefined;
+    private provision;
+    private ensureRobot;
+    private provisionRobot;
+    private startRobot;
+    private startGroup;
+    private history;
+    receiveGroup(groupId: string, data: Record<string, any>, live?: boolean): void;
+    receiveRobot(robotId: string, data: Record<string, any>): Promise<void>;
+    private execute;
+    ingest(event: ProcessEvent): void;
+    private settleSession;
+    private failRun;
+    private queueDelivery;
+    private pumpDeliveries;
+    private deliver;
+    send(id: string, requestId: string, input: string): Promise<ConversationReceipt>;
+    private linkEcho;
+    retryBinding(id: string): Promise<DingTalkJob>;
+    refreshGroup(id: string): Promise<DingTalkGroup>;
+    removeMirror(id: string): void;
+    removeBinding(id: string): {
+        removed: boolean;
+    };
+    updateBinding(id: string, input: {
+        paused?: unknown;
+        candidateIndex?: unknown;
+        allowGroupMembers?: unknown;
+    }): DingTalkBinding;
+    restore(): Promise<void>;
+    dispose(): void;
+}