@soimy/dingtalk 3.2.0 → 3.4.0

package/src/docs-service.ts

@@ -0,0 +1,198 @@
+import axios from "axios";
+import { getAccessToken } from "./auth";
+import { getLogger } from "./logger-context";
+import { getProxyBypassOption } from "./utils";
+import type { DingTalkConfig, DocInfo, Logger } from "./types";
+
+const DINGTALK_API = "https://api.dingtalk.com";
+
+async function buildHeaders(config: DingTalkConfig, log?: Logger): Promise<Record<string, string>> {
+  const token = await getAccessToken(config, log);
+  return {
+    "x-acs-dingtalk-access-token": token,
+    "Content-Type": "application/json",
+  };
+}
+
+type CreateDocResponse = {
+  docId?: string;
+  title?: string;
+  name?: string;
+  docType?: string;
+  creatorId?: string;
+  updatedAt?: number | string;
+};
+
+type SearchDocItem = {
+  docId?: string;
+  title?: string;
+  docType?: string;
+  creatorId?: string;
+  updatedAt?: number | string;
+};
+
+type ListDentryItem = {
+  dentryUuid?: string;
+  name?: string;
+  dentryType?: string;
+  creatorId?: string;
+  updatedAt?: number | string;
+};
+
+type AppendDocResponse = {
+  success?: boolean;
+};
+
+export class DocCreateAppendError extends Error {
+  readonly doc: DocInfo;
+
+  constructor(doc: DocInfo, cause?: unknown) {
+    super("initial content append failed after document creation");
+    this.name = "DocCreateAppendError";
+    this.doc = doc;
+    this.cause = cause;
+  }
+}
+
+function mapCreatedDoc(item: CreateDocResponse): DocInfo {
+  return {
+    docId: item.docId ?? "",
+    title: item.title ?? item.name ?? "",
+    docType: item.docType ?? "unknown",
+    creatorId: item.creatorId,
+    updatedAt: item.updatedAt,
+  };
+}
+
+function mapSearchDoc(item: SearchDocItem): DocInfo {
+  return {
+    docId: item.docId ?? "",
+    title: item.title ?? "",
+    docType: item.docType ?? "unknown",
+    creatorId: item.creatorId,
+    updatedAt: item.updatedAt,
+  };
+}
+
+function mapListDentry(item: ListDentryItem): DocInfo {
+  return {
+    docId: item.dentryUuid ?? "",
+    title: item.name ?? "",
+    docType: item.dentryType ?? "unknown",
+    creatorId: item.creatorId,
+    updatedAt: item.updatedAt,
+  };
+}
+
+export async function createDoc(
+  config: DingTalkConfig,
+  spaceId: string,
+  title: string,
+  content?: string,
+  log = getLogger(),
+  parentId?: string,
+): Promise<DocInfo> {
+  const headers = await buildHeaders(config, log);
+  const createResp = await axios.post(
+    `${DINGTALK_API}/v1.0/doc/spaces/${spaceId}/docs`,
+    {
+      spaceId,
+      ...(parentId ? { parentDentryId: parentId } : { parentDentryId: "" }),
+      name: title,
+      docType: "alidoc",
+    },
+    {
+      headers,
+      timeout: 10_000,
+      ...getProxyBypassOption(config),
+    },
+  );
+  const createdBase = mapCreatedDoc((createResp.data ?? {}) as CreateDocResponse);
+  const created = {
+    ...createdBase,
+    title: createdBase.title || title,
+    docType: createdBase.docType || "alidoc",
+  };
+  if (content?.trim() && created.docId) {
+    try {
+      await appendToDoc(config, created.docId, content, log);
+    } catch (error) {
+      throw new DocCreateAppendError(created, error);
+    }
+  }
+  return created;
+}
+
+export async function appendToDoc(
+  config: DingTalkConfig,
+  docId: string,
+  content: string,
+  log = getLogger(),
+  index = -1,
+): Promise<{ success: true }> {
+  const headers = await buildHeaders(config, log);
+  // DingTalk document block API accepts `index = -1` to append content at the end.
+  const resp = await axios.post(
+    `${DINGTALK_API}/v1.0/doc/documents/${docId}/blocks/root/children`,
+    {
+      blockType: "PARAGRAPH",
+      body: { text: content },
+      index,
+    },
+    {
+      headers,
+      timeout: 10_000,
+      ...getProxyBypassOption(config),
+    },
+  );
+  if ((resp.data as AppendDocResponse | undefined)?.success === false) {
+    throw new Error("appendToDoc failed");
+  }
+  return { success: true };
+}
+
+export async function searchDocs(
+  config: DingTalkConfig,
+  keyword: string,
+  spaceId?: string,
+  log = getLogger(),
+): Promise<DocInfo[]> {
+  const headers = await buildHeaders(config, log);
+  const resp = await axios.post(
+    `${DINGTALK_API}/v1.0/doc/docs/search`,
+    {
+      keyword,
+      maxResults: 20,
+      ...(spaceId ? { spaceId } : {}),
+    },
+    {
+      headers,
+      timeout: 10_000,
+      ...getProxyBypassOption(config),
+    },
+  );
+  return Array.isArray(resp.data?.items)
+    ? (resp.data.items as SearchDocItem[]).map(mapSearchDoc)
+    : [];
+}
+
+export async function listDocs(
+  config: DingTalkConfig,
+  spaceId: string,
+  parentId?: string,
+  log = getLogger(),
+): Promise<DocInfo[]> {
+  const headers = await buildHeaders(config, log);
+  const resp = await axios.get(`${DINGTALK_API}/v1.0/doc/spaces/${spaceId}/dentries`, {
+    headers,
+    params: {
+      maxResults: 50,
+      ...(parentId ? { parentDentryId: parentId } : {}),
+    },
+    timeout: 10_000,
+    ...getProxyBypassOption(config),
+  });
+  return Array.isArray(resp.data?.items)
+    ? (resp.data.items as ListDentryItem[]).map(mapListDentry)
+    : [];
+}

package/src/draft-stream-loop.ts

@@ -0,0 +1,119 @@
+/**
+ * Throttled stream loop for fire-and-forget draft updates.
+ *
+ * Ported from OpenClaw core (channels/draft-stream-loop.ts) because the module
+ * is not exported via the plugin-sdk.  Keeps the same interface so that future
+ * sync with upstream is straightforward.
+ *
+ * Key safety properties:
+ * - Single-flight: at most one `sendOrEditStreamMessage` is in-flight at any time.
+ * - Latest-wins: multiple `update()` calls during in-flight only keep the last text.
+ * - Throttle: respects `throttleMs` between consecutive sends.
+ * - `flush()` drains all pending + waits for in-flight before returning.
+ * - `stop()` clears pending and timers; subsequent `update()` calls are ignored.
+ */
+
+export type DraftStreamLoop = {
+    update: (text: string) => void;
+    flush: () => Promise<void>;
+    stop: () => void;
+    resetPending: () => void;
+    resetThrottleWindow: () => void;
+    waitForInFlight: () => Promise<void>;
+};
+
+export function createDraftStreamLoop(params: {
+    throttleMs: number;
+    isStopped: () => boolean;
+    sendOrEditStreamMessage: (text: string) => Promise<void | boolean>;
+}): DraftStreamLoop {
+    let lastSentAt = 0;
+    let pendingText = "";
+    let inFlightPromise: Promise<void | boolean> | undefined;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    const flush = async () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        while (!params.isStopped()) {
+            if (inFlightPromise) {
+                await inFlightPromise;
+                continue;
+            }
+            const text = pendingText;
+            if (!text.trim()) {
+                pendingText = "";
+                return;
+            }
+            pendingText = "";
+            const current = params.sendOrEditStreamMessage(text).finally(() => {
+                if (inFlightPromise === current) {
+                    inFlightPromise = undefined;
+                }
+            });
+            inFlightPromise = current;
+            const sent = await current;
+            if (sent === false) {
+                pendingText = text;
+                return;
+            }
+            lastSentAt = Date.now();
+            if (!pendingText) {
+                return;
+            }
+        }
+    };
+
+    const schedule = () => {
+        if (timer) {
+            return;
+        }
+        const delay = Math.max(0, params.throttleMs - (Date.now() - lastSentAt));
+        timer = setTimeout(() => {
+            void flush();
+        }, delay);
+    };
+
+    return {
+        update: (text: string) => {
+            if (params.isStopped()) {
+                return;
+            }
+            pendingText = text;
+            if (inFlightPromise) {
+                schedule();
+                return;
+            }
+            if (!timer && Date.now() - lastSentAt >= params.throttleMs) {
+                void flush();
+                return;
+            }
+            schedule();
+        },
+        flush,
+        stop: () => {
+            pendingText = "";
+            if (timer) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        },
+        resetPending: () => {
+            pendingText = "";
+        },
+        resetThrottleWindow: () => {
+            lastSentAt = 0;
+            if (timer) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        },
+        waitForInFlight: async () => {
+            if (inFlightPromise) {
+                await inFlightPromise;
+            }
+        },
+    };
+}