@insta-dev01/intclaw 1.0.10 → 1.1.0

package/src/targets.ts

@@ -0,0 +1,45 @@
+import type { IntclawMessageContext } from "./types/index.ts";
+
+function stripProviderPrefix(raw: string): string {
+  return raw.replace(/^(intclaw|dd|ding):/i, "").trim();
+}
+
+export function normalizeIntclawTarget(raw: string): string | null {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  const withoutProvider = stripProviderPrefix(trimmed);
+  const lowered = withoutProvider.toLowerCase();
+  if (lowered.startsWith("user:")) {
+    return withoutProvider.slice("user:".length).trim() || null;
+  }
+  if (lowered.startsWith("group:")) {
+    return withoutProvider.slice("group:".length).trim() || null;
+  }
+
+  return withoutProvider;
+}
+
+export function formatIntclawTarget(id: string, type?: "user" | "group"): string {
+  const trimmed = id.trim();
+  if (type === "group") {
+    return `group:${trimmed}`;
+  }
+  if (type === "user") {
+    return `user:${trimmed}`;
+  }
+  return trimmed;
+}
+
+export function looksLikeIntclawId(raw: string): boolean {
+  const trimmed = stripProviderPrefix(raw.trim());
+  if (!trimmed) {
+    return false;
+  }
+  if (/^(user|group):/i.test(trimmed)) {
+    return true;
+  }
+  return true;
+}

package/src/types/index.ts

@@ -0,0 +1,52 @@
+import type { BaseProbeResult } from "openclaw/plugin-sdk";
+import type {
+  IntclawConfigSchema,
+  IntclawGroupSchema,
+  IntclawAccountConfigSchema,
+  z,
+} from "../config/schema.ts";
+
+export type IntclawConfig = z.infer<typeof IntclawConfigSchema>;
+export type IntclawGroupConfig = z.infer<typeof IntclawGroupSchema>;
+export type IntclawAccountConfig = z.infer<typeof IntclawAccountConfigSchema>;
+
+export type IntclawConnectionMode = "stream";
+
+export type IntclawDefaultAccountSelectionSource =
+  | "explicit-default"
+  | "mapped-default"
+  | "fallback";
+export type IntclawAccountSelectionSource = "explicit" | IntclawDefaultAccountSelectionSource;
+
+export type ResolvedIntclawAccount = {
+  accountId: string;
+  selectionSource: IntclawAccountSelectionSource;
+  enabled: boolean;
+  configured: boolean;
+  name?: string;
+  clientId?: string;
+  clientSecret?: string;
+  /** Merged config (top-level defaults + account-specific overrides) */
+  config: IntclawConfig;
+};
+
+export type IntclawMessageContext = {
+  conversationId: string;
+  messageId: string;
+  senderId: string;
+  senderName?: string;
+  conversationType: "1" | "2"; // 1=单聊, 2=群聊
+  content: string;
+  contentType: string;
+  groupSubject?: string;
+};
+
+export type IntclawSendResult = {
+  messageId: string;
+  conversationId: string;
+};
+
+export type IntclawProbeResult = BaseProbeResult<string> & {
+  clientId?: string;
+  botName?: string;
+};

package/src/utils/agent.ts

@@ -0,0 +1,63 @@
+/**
+ * Agent 相关工具函数
+ * 
+ * 提供 Agent 配置解析、工作空间路径解析等功能
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+
+/**
+ * 解析 Agent 工作空间路径
+ * 
+ * 参考 OpenClaw SDK 的 resolveAgentWorkspaceDir 实现逻辑：
+ * 1. 优先从 agents.list 中查找用户配置的 workspace
+ * 2. 如果没有配置，使用默认路径规则：
+ *    - 默认 Agent (main): ~/.openclaw/workspace
+ *    - 其他 Agent: ~/.openclaw/workspace-{agentId}
+ * 
+ * @param cfg - OpenClaw 配置对象
+ * @param agentId - Agent ID
+ * @returns Agent 工作空间的绝对路径
+ * 
+ * @example
+ * ```typescript
+ * // 用户自定义工作空间
+ * const cfg = {
+ *   agents: {
+ *     list: [{ id: 'bot1', workspace: '~/my-workspace' }]
+ *   }
+ * };
+ * resolveAgentWorkspaceDir(cfg, 'bot1'); // => '/Users/xxx/my-workspace'
+ * 
+ * // 默认 Agent
+ * resolveAgentWorkspaceDir(cfg, 'main'); // => '/Users/xxx/.openclaw/workspace'
+ * 
+ * // 其他 Agent
+ * resolveAgentWorkspaceDir(cfg, 'bot2'); // => '/Users/xxx/.openclaw/workspace-bot2'
+ * ```
+ */
+export function resolveAgentWorkspaceDir(
+  cfg: ClawdbotConfig,
+  agentId: string,
+): string {
+  // 1. 先从 agents.list 中查找配置的 workspace
+  const agentConfig = cfg.agents?.list?.find((a: any) => a.id === agentId);
+  
+  if (agentConfig?.workspace) {
+    // 用户配置了自定义工作空间路径
+    // 支持 ~ 路径展开
+    return agentConfig.workspace.startsWith('~') 
+      ? path.join(os.homedir(), agentConfig.workspace.slice(1))
+      : agentConfig.workspace;
+  }
+  
+  // 2. 使用默认路径规则
+  if (agentId === 'main' || agentId === cfg.defaultAgent) {
+    // 默认 Agent 使用 ~/.openclaw/workspace
+    return path.join(os.homedir(), '.openclaw', 'workspace');
+  }
+  
+  // 其他 Agent 使用 ~/.openclaw/workspace-{agentId}
+  return path.join(os.homedir(), '.openclaw', `workspace-${agentId}`);
+}

package/src/utils/async.ts

@@ -0,0 +1,51 @@
+export type RaceResult<T> =
+  | { status: "success"; value: T }
+  | { status: "timeout" }
+  | { status: "aborted" };
+
+export async function raceWithTimeoutAndAbort<T>(
+  promise: Promise<T>,
+  opts: { timeoutMs: number; abortSignal?: AbortSignal },
+): Promise<RaceResult<T>> {
+  const { timeoutMs, abortSignal } = opts;
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  let abortHandler: (() => void) | undefined;
+
+  const timeoutOutcome = new Promise<{ kind: "timeout" }>((resolve) => {
+    timeoutId = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
+  });
+
+  const abortOutcome: Promise<{ kind: "aborted" }> | Promise<never> = abortSignal
+    ? new Promise<{ kind: "aborted" }>((resolve) => {
+        if (abortSignal.aborted) {
+          resolve({ kind: "aborted" });
+          return;
+        }
+        abortHandler = () => resolve({ kind: "aborted" });
+        abortSignal.addEventListener("abort", abortHandler, { once: true });
+      })
+    : new Promise<never>(() => {});
+
+  try {
+    const winner = await Promise.race([
+      promise.then((value) => ({ kind: "success" as const, value })),
+      timeoutOutcome,
+      abortOutcome,
+    ]);
+
+    if (winner.kind === "success") {
+      return { status: "success", value: winner.value };
+    }
+    if (winner.kind === "timeout") {
+      return { status: "timeout" };
+    }
+    return { status: "aborted" };
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    if (abortSignal && abortHandler) {
+      abortSignal.removeEventListener("abort", abortHandler);
+    }
+  }
+}

package/src/utils/constants.ts

@@ -0,0 +1,9 @@
+/**
+ * 常量定义模块
+ */
+
+/** 默认账号 ID，用于标记单账号模式（无 accounts 配置）时的内部标识 */
+export const DEFAULT_ACCOUNT_ID = '__default__';
+
+/** 新会话触发命令 */
+export const NEW_SESSION_COMMANDS = ['/new', '/reset', '/clear', '新会话', '重新开始', '清空对话'];

package/src/utils/http-client.ts

@@ -0,0 +1,84 @@
+/**
+ * HTTP 客户端配置模块
+ * 
+ * 提供统一的 axios 实例，禁用代理以避免系统 PAC 文件影响
+ * 
+ * 问题背景：
+ * - 阿里巴巴内网 PAC 文件会将 *.intclaw.com 路由到内网代理（如 192.168.1.176:443）
+ * - 当不在内网环境时，会导致连接超时
+ * 
+ * 解决方案：
+ * - 创建专用的 axios 实例，禁用代理
+ * - 仅影响IntClaw插件，不影响 OpenClaw Gateway 和其他插件
+ * 
+ * 使用方式：
+ * ```typescript
+ * import { intclawHttp } from './utils/http-client.ts';
+ * 
+ * const response = await intclawHttp.post('/api/endpoint', data);
+ * ```
+ */
+
+import axios, { type AxiosInstance, type CreateAxiosDefaults } from 'axios';
+
+/**
+ * 获取代理配置
+ * 
+ * 策略：
+ * 1. 如果设置了 INTCLAW_FORCE_PROXY=true，使用环境变量中的代理
+ * 2. 否则禁用代理（避免被系统 PAC 影响）
+ */
+function getProxyConfig(): CreateAxiosDefaults['proxy'] {
+  // 如果强制启用代理
+  if (process.env.INTCLAW_FORCE_PROXY === 'true') {
+    const proxyUrl =
+      process.env.https_proxy ||
+      process.env.HTTPS_PROXY ||
+      process.env.http_proxy ||
+      process.env.HTTP_PROXY;
+
+    if (proxyUrl) {
+      return proxyUrl as any;
+    }
+  }
+
+  // 默认禁用代理
+  return false;
+}
+
+/**
+ * IntClaw专用 HTTP 客户端
+ * 
+ * 特性：
+ * - 禁用代理（避免 PAC 文件影响）
+ * - 30 秒超时
+ * - 仅影响IntClaw插件的请求
+ */
+export const intclawHttp: AxiosInstance = axios.create({
+  proxy: getProxyConfig(),
+  timeout: 30000,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+/**
+ * IntClaw OAPI 专用 HTTP 客户端（用于媒体上传等）
+ */
+export const intclawOapiHttp: AxiosInstance = axios.create({
+  proxy: getProxyConfig(),
+  timeout: 60000, // 媒体上传可能需要更长时间
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+/**
+ * 用于文件上传的 HTTP 客户端（支持 multipart/form-data）
+ */
+export const intclawUploadHttp: AxiosInstance = axios.create({
+  proxy: getProxyConfig(),
+  timeout: 120000, // 文件上传需要更长时间
+  maxContentLength: Infinity,
+  maxBodyLength: Infinity,
+});

package/src/utils/index.ts

@@ -0,0 +1,8 @@
+/**
+ * 工具函数模块统一导出
+ */
+
+export * from './constants.ts';
+export * from './token.ts';
+export * from './session.ts';
+export * from './logger.ts';

package/src/utils/logger.ts

@@ -0,0 +1,78 @@
+/**
+ * 日志工具模块
+ * 根据 debug 配置控制日志输出
+ */
+
+/**
+ * 创建日志记录器
+ * @param debug - 是否启用 debug 模式
+ * @param prefix - 日志前缀
+ * @returns 日志记录器对象
+ */
+export function createLogger(debug: boolean = false, prefix: string = '') {
+  const logger = {
+    /**
+     * 打印 info 级别日志
+     * 仅在 debug 模式下输出
+     */
+    info(...args: any[]) {
+      if (debug) {
+        if (prefix) {
+          console.log(`[${prefix}]`, ...args);
+        } else {
+          console.log(...args);
+        }
+      }
+    },
+
+    /**
+     * 打印 warn 级别日志
+     * 始终输出
+     */
+    warn(...args: any[]) {
+      if (prefix) {
+        console.warn(`[${prefix}]`, ...args);
+      } else {
+        console.warn(...args);
+      }
+    },
+
+    /**
+     * 打印 error 级别日志
+     * 始终输出
+     */
+    error(...args: any[]) {
+      if (prefix) {
+        console.error(`[${prefix}]`, ...args);
+      } else {
+        console.error(...args);
+      }
+    },
+
+    /**
+     * 打印 debug 级别日志
+     * 仅在 debug 模式下输出
+     */
+    debug(...args: any[]) {
+      if (debug) {
+        if (prefix) {
+          console.log(`[DEBUG][${prefix}]`, ...args);
+        } else {
+          console.log('[DEBUG]', ...args);
+        }
+      }
+    },
+  };
+
+  return logger;
+}
+
+/**
+ * 从配置中创建日志记录器
+ * @param config - 包含 debug 配置的对象
+ * @param prefix - 日志前缀
+ * @returns 日志记录器对象
+ */
+export function createLoggerFromConfig(config: { debug?: boolean }, prefix: string = '') {
+  return createLogger(!!config.debug, prefix);
+}

package/src/utils/session.ts

@@ -0,0 +1,118 @@
+/**
+ * 会话管理模块
+ * 构建 OpenClaw 标准会话上下文
+ */
+
+import { NEW_SESSION_COMMANDS } from './constants.ts';
+
+/** OpenClaw 标准会话上下文 */
+export interface SessionContext {
+  channel: 'intclaw-connector';
+  accountId: string;
+  chatType: 'direct' | 'group';
+  peerId: string;
+  conversationId?: string;
+  senderName?: string;
+  groupSubject?: string;
+}
+
+/**
+ * 构建 OpenClaw 标准会话上下文
+ * 遵循 OpenClaw session.dmScope 机制，让 Gateway 根据配置自动处理会话隔离
+ * 
+ * @param sharedMemoryAcrossConversations - 是否在不同会话间共享记忆（默认 false）
+ *   - true: 所有会话共享记忆，使用 accountId 作为记忆标识
+ *   - false: 不同会话独立记忆，使用完整的 sessionContext 作为记忆标识
+ */
+export function buildSessionContext(params: {
+  accountId: string;
+  senderId: string;
+  senderName?: string;
+  conversationType: string;
+  conversationId?: string;
+  groupSubject?: string;
+  separateSessionByConversation?: boolean;
+  groupSessionScope?: 'group' | 'group_sender';
+  sharedMemoryAcrossConversations?: boolean;
+}): SessionContext {
+  const {
+    accountId,
+    senderId,
+    senderName,
+    conversationType,
+    conversationId,
+    groupSubject,
+    separateSessionByConversation,
+    groupSessionScope,
+    sharedMemoryAcrossConversations,
+  } = params;
+  const isDirect = conversationType === '1';
+
+  // sharedMemoryAcrossConversations=true 时，所有会话共享记忆
+  // 通过将 peerId 设置为 accountId 来实现跨会话记忆共享
+  if (sharedMemoryAcrossConversations === true) {
+    return {
+      channel: 'intclaw-connector',
+      accountId,
+      chatType: isDirect ? 'direct' : 'group',
+      peerId: accountId, // 使用 accountId 作为 peerId，实现跨会话记忆共享
+      conversationId: isDirect ? undefined : conversationId,
+      senderName,
+      groupSubject: isDirect ? undefined : groupSubject,
+    };
+  }
+
+  if (separateSessionByConversation === false) {
+    return {
+      channel: 'intclaw-connector',
+      accountId,
+      chatType: isDirect ? 'direct' : 'group',
+      peerId: senderId,
+      senderName,
+    };
+  }
+
+  if (isDirect) {
+    return {
+      channel: 'intclaw-connector',
+      accountId,
+      chatType: 'direct',
+      peerId: senderId,
+      senderName,
+    };
+  }
+
+  if (groupSessionScope === 'group_sender') {
+    return {
+      channel: 'intclaw-connector',
+      accountId,
+      chatType: 'group',
+      peerId: `${conversationId}:${senderId}`,
+      conversationId,
+      senderName,
+      groupSubject,
+    };
+  }
+
+  return {
+    channel: 'intclaw-connector',
+    accountId,
+    chatType: 'group',
+    peerId: conversationId || senderId,
+    conversationId,
+    senderName,
+    groupSubject,
+  };
+}
+
+/**
+ * 检查消息是否是新会话命令
+ */
+export function normalizeSlashCommand(text: string): string {
+  const trimmed = text.trim();
+  const lower = trimmed.toLowerCase();
+  if (NEW_SESSION_COMMANDS.some((cmd) => lower === cmd.toLowerCase())) {
+    return '/new';
+  }
+  return text;
+}

package/src/utils/token.ts

@@ -0,0 +1,94 @@
+/**
+ * Access Token 管理模块
+ * 支持IntClaw API 和 OAPI 的 Token 获取和缓存
+ */
+
+import type { IntclawConfig } from '../types/index.ts';
+import { intclawHttp, intclawOapiHttp } from './http-client.ts';
+import { INTCLAW_CONFIG } from '../../config.ts';
+
+// ============ 常量 ============
+
+export const INTCLAW_API = INTCLAW_CONFIG.API_BASE_URL;
+export const INTCLAW_OAPI = INTCLAW_CONFIG.OAPI_BASE_URL;
+
+// ============ Access Token 缓存 ============
+
+type CachedToken = {
+  token: string;
+  expiryMs: number;
+};
+
+/**
+ * 按 clientId 分桶缓存，避免多账号串 token。
+ */
+const apiTokenCache = new Map<string, CachedToken>();
+const oapiTokenCache = new Map<string, CachedToken>();
+
+function cacheKey(config: IntclawConfig): string {
+  const clientId = String((config as any)?.clientId ?? '').trim();
+  
+  // 添加校验
+  if (!clientId) {
+    throw new Error(
+      'Invalid IntclawConfig: clientId is required for token caching. ' +
+      'Please ensure your configuration includes a valid clientId.'
+    );
+  }
+  
+  return clientId;
+}
+
+/**
+ * 获取IntClaw Access Token（新版 API）
+ */
+export async function getAccessToken(config: IntclawConfig): Promise<string> {
+  const now = Date.now();
+  const key = cacheKey(config);
+  const cached = apiTokenCache.get(key);
+  if (cached && cached.expiryMs > now + 60_000) {
+    return cached.token;
+  }
+
+  const response = await intclawHttp.post(`${INTCLAW_API}/v1.0/oauth2/accessToken`, {
+    appKey: config.clientId,
+    appSecret: config.clientSecret,
+  });
+
+  const token = response.data.accessToken as string;
+  const expireInSec = Number(response.data.expireIn ?? 0);
+  apiTokenCache.set(key, {
+    token,
+    expiryMs: now + expireInSec * 1000,
+  });
+  return token;
+}
+
+/**
+ * 获取IntClaw OAPI Access Token（旧版 API，用于媒体上传等）
+ */
+export async function getOapiAccessToken(config: IntclawConfig): Promise<string | null> {
+  try {
+    const now = Date.now();
+    const key = cacheKey(config);
+    const cached = oapiTokenCache.get(key);
+    if (cached && cached.expiryMs > now + 60_000) {
+      return cached.token;
+    }
+
+    const resp = await intclawOapiHttp.get(`${INTCLAW_OAPI}/gettoken`, {
+      params: { appkey: config.clientId, appsecret: config.clientSecret },
+    });
+
+    if (resp.data?.errcode === 0 && resp.data?.access_token) {
+      const token = String(resp.data.access_token);
+      // IntClaw返回 expires_in（秒），拿不到就按 2 小时兜底
+      const expiresInSec = Number(resp.data.expires_in ?? 7200);
+      oapiTokenCache.set(key, { token, expiryMs: now + expiresInSec * 1000 });
+      return token;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}