@nextclaw/channel-plugin-feishu 0.2.14 → 0.2.15

package/src/nextclaw-sdk/types.ts

@@ -0,0 +1,300 @@
+export type LogFn = (message: string) => void;
+
+export type SecretRefSource = "env" | "file" | "exec";
+
+export type SecretRef = {
+  source: SecretRefSource;
+  provider: string;
+  id: string;
+};
+
+export type SecretInput = string | SecretRef;
+
+export type DmPolicy = "open" | "pairing" | "allowlist";
+export type GroupPolicy = "open" | "allowlist" | "disabled";
+
+export type AllowlistMatch<TSource extends string = string> = {
+  allowed: boolean;
+  matchKey?: string;
+  matchSource?: TSource;
+};
+
+export type BaseProbeResult<TTarget = string> = {
+  ok: boolean;
+  target?: TTarget;
+  error?: string;
+  [key: string]: unknown;
+};
+
+export type ReplyPayload = {
+  text?: string;
+  mediaUrl?: string;
+  mediaUrls?: string[];
+  [key: string]: unknown;
+};
+
+export type HistoryEntry = {
+  sender: string;
+  body: string;
+  timestamp?: number;
+  messageId?: string;
+};
+
+export type GroupToolPolicyConfig = Record<string, unknown>;
+
+export type ChannelGroupContext = {
+  cfg: ClawdbotConfig;
+  groupId?: string | null;
+  [key: string]: unknown;
+};
+
+export type ChannelMeta = {
+  id: string;
+  label: string;
+  selectionLabel?: string;
+  docsPath?: string;
+  docsLabel?: string;
+  blurb?: string;
+  aliases?: string[];
+  order?: number;
+  [key: string]: unknown;
+};
+
+export type ChannelPlugin<ResolvedAccount = unknown> = {
+  id: string;
+  meta: ChannelMeta;
+  config?: Record<string, unknown>;
+  onboarding?: ChannelOnboardingAdapter;
+  [key: string]: unknown;
+  __resolvedAccountType__?: ResolvedAccount;
+};
+
+export type ChannelOutboundAdapter = Record<string, unknown>;
+
+export type AnyAgentTool = {
+  name?: string;
+  description?: string;
+  parameters?: Record<string, unknown>;
+  execute?: (toolCallId: string, params: unknown) => Promise<unknown> | unknown;
+  [key: string]: unknown;
+};
+
+export type ResolvedAgentRoute = {
+  agentId?: string;
+  sessionKey?: string;
+  [key: string]: unknown;
+};
+
+export type InboundDebouncer<T> = {
+  run: (key: string, value: T, task: (value: T) => Promise<void>) => void;
+  clear: () => void;
+};
+
+export type PluginRuntime = {
+  version?: string;
+  config: {
+    loadConfig?: () => OpenClawConfig;
+    writeConfigFile: (next: OpenClawConfig) => Promise<void>;
+  };
+  logging: {
+    shouldLogVerbose: () => boolean;
+  };
+  media: {
+    detectMime: (params: { buffer: Buffer }) => Promise<string | undefined>;
+    loadWebMedia: (
+      url: string,
+      options?: Record<string, unknown>,
+    ) => Promise<Record<string, unknown>>;
+  };
+  channel: {
+    media: {
+      fetchRemoteMedia: (params: {
+        url: string;
+        maxBytes?: number;
+      }) => Promise<Record<string, unknown>>;
+      saveMediaBuffer: (
+        buffer: Buffer,
+        contentType?: string,
+        direction?: string,
+        maxBytes?: number,
+      ) => Promise<{ path: string; contentType?: string }>;
+    };
+    text: {
+      chunkMarkdownText: (text: string, limit: number) => string[];
+      resolveMarkdownTableMode: (params: Record<string, unknown>) => unknown;
+      convertMarkdownTables: (text: string, mode?: unknown) => string;
+      resolveTextChunkLimit: (
+        cfg: OpenClawConfig,
+        channel: string,
+        accountId?: string,
+        options?: Record<string, unknown>,
+      ) => number;
+      resolveChunkMode: (cfg: OpenClawConfig, channel: string) => string;
+      chunkTextWithMode: (text: string, limit: number, mode?: unknown) => string[];
+      hasControlCommand: (text: string, cfg: OpenClawConfig) => boolean;
+    };
+    reply: {
+      resolveEnvelopeFormatOptions: (cfg: OpenClawConfig) => Record<string, unknown>;
+      formatAgentEnvelope: (params: Record<string, unknown>) => string;
+      finalizeInboundContext: (params: Record<string, unknown>) => Record<string, unknown>;
+      withReplyDispatcher: (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+      dispatchReplyFromConfig: (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+      createReplyDispatcherWithTyping: (params: Record<string, unknown>) => {
+        dispatcher: unknown;
+        replyOptions: Record<string, unknown>;
+        markDispatchIdle: () => void;
+      };
+      resolveHumanDelayConfig: (cfg: OpenClawConfig, agentId: string) => unknown;
+      dispatchReplyWithBufferedBlockDispatcher?: (
+        params: Record<string, unknown>,
+      ) => Promise<void>;
+    };
+    routing: {
+      resolveAgentRoute: (params: Record<string, unknown>) => ResolvedAgentRoute | null;
+    };
+    pairing: {
+      readAllowFromStore: (params: { channel: string; accountId?: string }) => unknown;
+      upsertPairingRequest: (params: Record<string, unknown>) => Promise<{
+        code: string;
+        created: boolean;
+      }>;
+    };
+    commands: {
+      shouldComputeCommandAuthorized: (text: string) => boolean;
+      resolveCommandAuthorizedFromAuthorizers: (
+        params: Record<string, unknown>,
+      ) => Promise<boolean> | boolean;
+    };
+    debounce: {
+      resolveInboundDebounceMs: (params: Record<string, unknown>) => number;
+      createInboundDebouncer: <T>(params: Record<string, unknown>) => InboundDebouncer<T>;
+    };
+  };
+  [key: string]: unknown;
+};
+
+export type RuntimeEnv = {
+  log?: (message: string) => void;
+  error?: (message: string) => void;
+  warn?: (message: string) => void;
+  debug?: (message: string) => void;
+  info?: (message: string) => void;
+  [key: string]: unknown;
+};
+
+export type OpenClawPluginApi = {
+  config: ClawdbotConfig;
+  runtime: PluginRuntime;
+  logger: {
+    info: LogFn;
+    warn: LogFn;
+    error: LogFn;
+    debug?: LogFn;
+  };
+  registerTool: (
+    tool:
+      | AnyAgentTool
+      | ((ctx: Record<string, unknown>) => AnyAgentTool | AnyAgentTool[] | null | undefined),
+    opts?: { name?: string; names?: string[]; optional?: boolean },
+  ) => void;
+  registerChannel: (registration: unknown) => void;
+  [key: string]: unknown;
+};
+
+export type WizardSelectOption<T extends string = string> = {
+  value: T;
+  label: string;
+  hint?: string;
+};
+
+export type WizardPrompter = {
+  note: (message: string, title?: string) => Promise<void>;
+  text: (params: {
+    message: string;
+    placeholder?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | undefined;
+  }) => Promise<string>;
+  confirm: (params: { message: string; initialValue?: boolean }) => Promise<boolean>;
+  select: <T extends string = string>(params: {
+    message: string;
+    options: WizardSelectOption<T>[];
+    initialValue?: T | string;
+  }) => Promise<T>;
+};
+
+export type ChannelOnboardingDmPolicy = {
+  label: string;
+  channel: string;
+  policyKey: string;
+  allowFromKey: string;
+  getCurrent: (cfg: ClawdbotConfig) => DmPolicy;
+  setPolicy: (cfg: ClawdbotConfig, policy: DmPolicy) => ClawdbotConfig;
+  promptAllowFrom: (params: {
+    cfg: ClawdbotConfig;
+    prompter: WizardPrompter;
+  }) => Promise<ClawdbotConfig>;
+};
+
+export type ChannelOnboardingAdapter = {
+  channel: string;
+  getStatus: (params: { cfg: ClawdbotConfig }) => Promise<{
+    channel: string;
+    configured: boolean;
+    statusLines: string[];
+    selectionHint?: string;
+    quickstartScore?: number;
+  }>;
+  configure: (params: {
+    cfg: ClawdbotConfig;
+    prompter: WizardPrompter;
+  }) => Promise<{ cfg: ClawdbotConfig; accountId?: string }>;
+  dmPolicy?: ChannelOnboardingDmPolicy;
+  disable?: (cfg: ClawdbotConfig) => ClawdbotConfig;
+};
+
+export type OpenClawConfig = {
+  channels?: Record<string, Record<string, unknown> | undefined>;
+  bindings?: Array<{
+    agentId?: string;
+    match?: {
+      channel?: string;
+      peer?: {
+        kind?: string;
+        id?: string;
+      };
+    };
+  }>;
+  agents?: {
+    list?: Array<{
+      id: string;
+      workspace?: string;
+      agentDir?: string;
+      [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+  };
+  broadcast?: Record<string, string[]>;
+  secrets?: {
+    defaults?: {
+      env?: string;
+      file?: string;
+      exec?: string;
+    };
+    providers?: Record<
+      string,
+      {
+        source?: SecretRefSource;
+        path?: string;
+        mode?: "singleValue" | "json";
+        command?: string;
+        args?: string[];
+        [key: string]: unknown;
+      }
+    >;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+};
+
+export type ClawdbotConfig = OpenClawConfig;

package/src/onboarding.status.test.ts

@@ -1,4 +1,4 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/feishu";
+import type { OpenClawConfig } from "./nextclaw-sdk/feishu.js";
 import { describe, expect, it } from "vitest";
 import { feishuOnboardingAdapter } from "./onboarding.js";
 

package/src/onboarding.ts

@@ -5,7 +5,7 @@ import type {
   DmPolicy,
   SecretInput,
   WizardPrompter,
-} from "openclaw/plugin-sdk/feishu";
+} from "./nextclaw-sdk/feishu.js";
 import {
   buildSingleChannelSecretPromptState,
   DEFAULT_ACCOUNT_ID,
@@ -17,7 +17,7 @@ import {
   setTopLevelChannelDmPolicyWithAllowFrom,
   setTopLevelChannelGroupPolicy,
   splitOnboardingEntries,
-} from "openclaw/plugin-sdk/feishu";
+} from "./nextclaw-sdk/feishu.js";
 import { resolveFeishuCredentials } from "./accounts.js";
 import { probeFeishu } from "./probe.js";
 import type { FeishuConfig } from "./types.js";

package/src/outbound.ts

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk/feishu";
+import type { ChannelOutboundAdapter } from "./nextclaw-sdk/feishu.js";
 import { resolveFeishuAccount } from "./accounts.js";
 import { sendMediaFeishu } from "./media.js";
 import { getFeishuRuntime } from "./runtime.js";

package/src/perm.ts

@@ -1,5 +1,5 @@
 import type * as Lark from "@larksuiteoapi/node-sdk";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/feishu";
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
 import { listEnabledFeishuAccounts } from "./accounts.js";
 import { FeishuPermSchema, type FeishuPermParams } from "./perm-schema.js";
 import { createFeishuToolClient, resolveAnyEnabledFeishuToolsConfig } from "./tool-account.js";

package/src/policy.ts

@@ -2,8 +2,8 @@ import type {
   AllowlistMatch,
   ChannelGroupContext,
   GroupToolPolicyConfig,
-} from "openclaw/plugin-sdk/feishu";
-import { evaluateSenderGroupAccessForPolicy } from "openclaw/plugin-sdk/feishu";
+} from "./nextclaw-sdk/feishu.js";
+import { evaluateSenderGroupAccessForPolicy } from "./nextclaw-sdk/feishu.js";
 import { normalizeFeishuTarget } from "./targets.js";
 import type { FeishuConfig, FeishuGroupConfig } from "./types.js";
 

package/src/reactions.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk/feishu";
+import type { ClawdbotConfig } from "./nextclaw-sdk/feishu.js";
 import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 

package/src/reply-dispatcher.ts

@@ -5,7 +5,7 @@ import {
   type ClawdbotConfig,
   type ReplyPayload,
   type RuntimeEnv,
-} from "openclaw/plugin-sdk/feishu";
+} from "./nextclaw-sdk/feishu.js";
 import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 import { sendMediaFeishu } from "./media.js";

package/src/runtime.ts

@@ -1,5 +1,5 @@
-import { createPluginRuntimeStore } from "openclaw/plugin-sdk/compat";
-import type { PluginRuntime } from "openclaw/plugin-sdk/feishu";
+import { createPluginRuntimeStore } from "./nextclaw-sdk/compat.js";
+import type { PluginRuntime } from "./nextclaw-sdk/feishu.js";
 
 const { setRuntime: setFeishuRuntime, getRuntime: getFeishuRuntime } =
   createPluginRuntimeStore<PluginRuntime>("Feishu runtime not initialized");

package/src/secret-input.ts

@@ -3,7 +3,7 @@ import {
   hasConfiguredSecretInput,
   normalizeResolvedSecretInputString,
   normalizeSecretInputString,
-} from "openclaw/plugin-sdk/feishu";
+} from "./nextclaw-sdk/feishu.js";
 
 export {
   buildSecretInputSchema,

package/src/send-target.test.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk/feishu";
+import type { ClawdbotConfig } from "./nextclaw-sdk/feishu.js";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { resolveFeishuSendTarget } from "./send-target.js";
 

package/src/send-target.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk/feishu";
+import type { ClawdbotConfig } from "./nextclaw-sdk/feishu.js";
 import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 import { resolveReceiveIdType, normalizeFeishuTarget } from "./targets.js";

package/src/send.test.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk/feishu";
+import type { ClawdbotConfig } from "./nextclaw-sdk/feishu.js";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { getMessageFeishu } from "./send.js";
 

package/src/send.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk/feishu";
+import type { ClawdbotConfig } from "./nextclaw-sdk/feishu.js";
 import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 import type { MentionTarget } from "./mention.js";

package/src/streaming-card.ts

@@ -3,7 +3,7 @@
  */
 
 import type { Client } from "@larksuiteoapi/node-sdk";
-import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/feishu";
+import { fetchWithSsrFGuard } from "./nextclaw-sdk/feishu.js";
 import type { FeishuDomain } from "./types.js";
 
 type Credentials = { appId: string; appSecret: string; domain?: FeishuDomain };

package/src/tool-account-routing.test.ts

@@ -1,4 +1,4 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/feishu";
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { registerFeishuBitableTools } from "./bitable.js";
 import { registerFeishuDriveTools } from "./drive.js";

package/src/tool-account.ts

@@ -1,5 +1,5 @@
 import type * as Lark from "@larksuiteoapi/node-sdk";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/feishu";
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
 import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 import { resolveToolsConfig } from "./tools-config.js";

package/src/tool-factory-test-harness.ts

@@ -1,4 +1,4 @@
-import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk/feishu";
+import type { AnyAgentTool, OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
 
 type ToolContextLike = {
   agentAccountId?: string;

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { BaseProbeResult } from "openclaw/plugin-sdk/feishu";
+import type { BaseProbeResult } from "./nextclaw-sdk/feishu.js";
 import type {
   FeishuConfigSchema,
   FeishuGroupSchema,

package/src/typing.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk/feishu";
+import type { ClawdbotConfig, RuntimeEnv } from "./nextclaw-sdk/feishu.js";
 import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 import { getFeishuRuntime } from "./runtime.js";

package/src/wiki.ts

@@ -1,5 +1,5 @@
 import type * as Lark from "@larksuiteoapi/node-sdk";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/feishu";
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
 import { listEnabledFeishuAccounts } from "./accounts.js";
 import { createFeishuToolClient, resolveAnyEnabledFeishuToolsConfig } from "./tool-account.js";
 import {