openclaw-extension-typex 1.0.0

package/README.md

@@ -0,0 +1,49 @@
+# @openclaw/typex
+
+TypeX channel plugin for OpenClaw.
+
+This plugin is modeled after the Feishu channel plugin in `extensions/feishu/`, so you can
+use that implementation as a reference when wiring up the real TypeX provider.
+
+## Install (local checkout)
+
+```bash
+openclaw plugins install ./extensions/typex
+```
+
+## Install (npm)
+
+```bash
+openclaw plugins install @openclaw/typex
+```
+
+Onboarding: select TypeX and confirm the install prompt to fetch the plugin automatically.
+
+## Config
+
+```json5
+{
+  channels: {
+    typex: {
+      accounts: {
+        default: {
+          appId: "app_xxx",
+          appSecret: "xxx",
+          enabled: true,
+        },
+      },
+      dmPolicy: "pairing",
+      groupPolicy: "open",
+      blockStreaming: true,
+    },
+  },
+}
+```
+
+Once the actual TypeX provider is implemented in the core `openclaw` repo, you can extend
+this plugin to wire outbound messaging and gateway/runtime logic, mirroring the Feishu
+implementation.
+
+## Docs
+
+https://docs.openclaw.ai/channels/typex

package/dist/client/accounts.d.ts

@@ -0,0 +1,16 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { TypeXAccountConfig } from "../types.js";
+export type TypeXTokenSource = "config" | "file" | "env" | "none";
+export type ResolvedTypeXAccount = {
+    accountId: string;
+    config: TypeXAccountConfig;
+    tokenSource: TypeXTokenSource;
+    name?: string;
+    enabled: boolean;
+};
+export declare function listTypeXAccountIds(cfg: OpenClawConfig): string[];
+export declare function resolveDefaultTypeXAccountId(cfg: OpenClawConfig): string;
+export declare function resolveTypeXAccount(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+}): ResolvedTypeXAccount;

package/dist/client/accounts.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listTypeXAccountIds = listTypeXAccountIds;
+exports.resolveDefaultTypeXAccountId = resolveDefaultTypeXAccountId;
+exports.resolveTypeXAccount = resolveTypeXAccount;
+const node_fs_1 = __importDefault(require("node:fs"));
+const plugin_sdk_1 = require("openclaw/plugin-sdk");
+function readFileIfExists(filePath) {
+    if (!filePath) {
+        return undefined;
+    }
+    try {
+        return node_fs_1.default.readFileSync(filePath, "utf-8").trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveAccountConfig(cfg, accountId) {
+    const accounts = cfg.channels?.typex?.accounts;
+    if (!accounts || typeof accounts !== "object") {
+        return undefined;
+    }
+    const direct = accounts[accountId];
+    if (direct) {
+        return direct;
+    }
+    const normalized = (0, plugin_sdk_1.normalizeAccountId)(accountId);
+    const matchKey = Object.keys(accounts).find((key) => (0, plugin_sdk_1.normalizeAccountId)(key) === normalized);
+    return matchKey ? accounts[matchKey] : undefined;
+}
+function mergeTypeXAccountConfig(cfg, accountId) {
+    const { accounts: _ignored, ...base } = (cfg.channels?.typex ?? {});
+    const account = resolveAccountConfig(cfg, accountId) ?? {};
+    return { ...base, ...account };
+}
+function resolveAppSecret(config) {
+    const direct = config?.appSecret?.trim();
+    if (direct) {
+        return { value: direct, source: "config" };
+    }
+    const fromFile = readFileIfExists(config?.appSecretFile);
+    if (fromFile) {
+        return { value: fromFile, source: "file" };
+    }
+    return {};
+}
+function listTypeXAccountIds(cfg) {
+    const typexCfg = cfg.channels?.typex;
+    const accounts = typexCfg?.accounts;
+    const ids = new Set();
+    const baseConfigured = Boolean(typexCfg?.appId?.trim() && (typexCfg?.appSecret?.trim() || Boolean(typexCfg?.appSecretFile)));
+    const envConfigured = Boolean(process.env.TYPEX_APP_ID?.trim() && process.env.TYPEX_APP_SECRET?.trim());
+    if (baseConfigured || envConfigured) {
+        ids.add(plugin_sdk_1.DEFAULT_ACCOUNT_ID);
+    }
+    if (accounts) {
+        for (const id of Object.keys(accounts)) {
+            ids.add((0, plugin_sdk_1.normalizeAccountId)(id));
+        }
+    }
+    return Array.from(ids);
+}
+function resolveDefaultTypeXAccountId(cfg) {
+    const ids = listTypeXAccountIds(cfg);
+    if (ids.includes(plugin_sdk_1.DEFAULT_ACCOUNT_ID)) {
+        return plugin_sdk_1.DEFAULT_ACCOUNT_ID;
+    }
+    return ids[0] ?? plugin_sdk_1.DEFAULT_ACCOUNT_ID;
+}
+function resolveTypeXAccount(params) {
+    const accountId = (0, plugin_sdk_1.normalizeAccountId)(params.accountId);
+    const baseEnabled = params.cfg.channels?.typex?.enabled !== false;
+    const merged = mergeTypeXAccountConfig(params.cfg, accountId);
+    const accountEnabled = merged.enabled !== false;
+    const enabled = baseEnabled && accountEnabled;
+    const allowEnv = accountId === plugin_sdk_1.DEFAULT_ACCOUNT_ID;
+    const envAppId = allowEnv ? process.env.TYPEX_APP_ID?.trim() : undefined;
+    const envAppSecret = allowEnv ? process.env.TYPEX_APP_SECRET?.trim() : undefined;
+    const appId = merged.appId?.trim() || envAppId || "";
+    const secretResolution = resolveAppSecret(merged);
+    const appSecret = secretResolution.value ?? envAppSecret ?? "";
+    let tokenSource = "none";
+    if (secretResolution.value) {
+        tokenSource = secretResolution.source ?? "config";
+    }
+    else if (envAppSecret) {
+        tokenSource = "env";
+    }
+    if (!appId || !appSecret) {
+        tokenSource = "none";
+    }
+    const config = {
+        ...merged,
+        appId,
+        appSecret,
+    };
+    const name = config.name?.trim() || config.botName?.trim() || undefined;
+    return {
+        accountId,
+        config,
+        tokenSource,
+        name,
+        enabled,
+    };
+}

package/dist/client/client.d.ts

@@ -0,0 +1,14 @@
+import { TypeXMessageEnum, type TypeXClientOptions } from "./types.js";
+export declare class TypeXClient {
+    private options;
+    private accessToken?;
+    private userId?;
+    constructor(options: TypeXClientOptions);
+    getAccessToken(): Promise<string>;
+    getCurUserId(): Promise<string>;
+    fetchQrcodeUrl(): Promise<any>;
+    checkLoginStatus(qrcodeId: string): Promise<boolean>;
+    sendMessage(content: string | object, msgType?: TypeXMessageEnum): Promise<any>;
+    fetchMessages(pos: number): Promise<any>;
+}
+export declare function getTypeXClient(accountId?: string, manualOptions?: TypeXClientOptions): TypeXClient;

package/dist/client/client.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeXClient = void 0;
+exports.getTypeXClient = getTypeXClient;
+const TYPEX_DOMAIN = "https://api-coco.typex.im";
+// const TYPEX_DOMAIN = "https://api-tx.bossjob.net.cn";
+let prompter;
+class TypeXClient {
+    options;
+    accessToken;
+    userId;
+    constructor(options) {
+        this.options = options;
+        if (options.token) {
+            this.accessToken = options.token;
+        }
+    }
+    async getAccessToken() {
+        if (this.accessToken) {
+            return this.accessToken;
+        }
+        return "";
+    }
+    async getCurUserId() {
+        if (this.userId) {
+            return this.userId;
+        }
+        return "";
+    }
+    async fetchQrcodeUrl() {
+        try {
+            const qrResponse = await fetch(`${TYPEX_DOMAIN}/user/qrcode?login_type=open`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({}),
+            });
+            if (!qrResponse.ok) {
+                throw new Error(`Failed to get QR code: ${qrResponse.statusText}`);
+            }
+            const qrResult = await qrResponse.json();
+            if (qrResult.code !== 0 || !qrResult.data) {
+                throw new Error(`Failed to get QR code: ${qrResult.msg}`);
+            }
+            return qrResult.data;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async checkLoginStatus(qrcodeId) {
+        try {
+            const checkRes = await fetch(`${TYPEX_DOMAIN}/open/qrcode/check_auth`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    qr_code_id: qrcodeId,
+                }),
+            });
+            const setCookieHeader = checkRes.headers.get("set-cookie");
+            if (setCookieHeader) {
+                const match = setCookieHeader.match(/(sessionid=[^;]+)/);
+                if (match && match[1]) {
+                    this.accessToken = match[1];
+                }
+            }
+            const checkData = await checkRes.json();
+            if (checkData.code === 0) {
+                const { user_id } = checkData.data;
+                this.userId = user_id;
+                return true;
+            }
+            else if (checkData.code === 10001) {
+                return false;
+            }
+            else {
+                return false;
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async sendMessage(content, msgType = 0) {
+        const token = this.accessToken;
+        if (!token) {
+            throw new Error("TypeXClient: Not authenticated.");
+        }
+        let finalContent = content;
+        if (typeof content === "object") {
+            try {
+                finalContent = JSON.stringify(content);
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    prompter.note("Failed to stringify message content");
+                }
+                finalContent = String(content);
+            }
+        }
+        prompter.note(`TypeXClient sending message: content=${typeof finalContent === "string" ? finalContent : JSON.stringify(finalContent)}`);
+        try {
+            const url = `${TYPEX_DOMAIN}/open/claw/send_message`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Cookie: token,
+                },
+                body: JSON.stringify({
+                    content: {
+                        text: finalContent,
+                    },
+                    msg_type: msgType,
+                }),
+            });
+            const resJson = await response.json();
+            if (resJson.code !== 0) {
+                throw new Error(`Send message failed: [${resJson.code}] ${resJson.message}`);
+            }
+            prompter.note("Message sent successfully", resJson.data);
+            return (resJson.data || {
+                message_id: `msg_${Date.now()}`,
+            });
+        }
+        catch (error) {
+            prompter.note(`Error sending message to TypeX API: ${error}`);
+            throw error;
+        }
+    }
+    async fetchMessages(pos) {
+        if (!this.accessToken) {
+            prompter.note("TypeXClient: No token, skipping fetch.");
+            return [];
+        }
+        try {
+            const url = `${TYPEX_DOMAIN}/open/claw/message`;
+            prompter.note(`Fetching messages from pos: ${pos}`);
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    Cookie: this.accessToken,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ pos: pos }),
+            });
+            const resJson = await response.json();
+            if (resJson.code !== 0) {
+                prompter.note(`Fetch failed with code ${resJson.code}: ${resJson.message}`);
+                return [];
+            }
+            if (Array.isArray(resJson.data)) {
+                return resJson.data;
+            }
+            return [];
+        }
+        catch (e) {
+            prompter.note(`Fetch messages network error: ${e}`);
+            return [];
+        }
+    }
+}
+exports.TypeXClient = TypeXClient;
+function getTypeXClient(accountId, manualOptions) {
+    const typexCfg = (manualOptions?.typexCfg ?? {});
+    const clawPrompter = manualOptions?.prompter;
+    if (clawPrompter) {
+        prompter = clawPrompter;
+    }
+    let token = manualOptions?.token;
+    if (accountId && typexCfg.accounts?.[accountId]) {
+        token = typexCfg.accounts[accountId].token;
+    }
+    if (!manualOptions?.skipConfigCheck) {
+        throw new Error("TypeX email not configured yet.");
+    }
+    return new TypeXClient({
+        token: token,
+    });
+}

package/dist/client/config.d.ts

@@ -0,0 +1,25 @@
+import type { OpenClawConfig, DmPolicy, GroupPolicy } from "openclaw/plugin-sdk";
+import type { TypeXGroupConfig } from "../types";
+export type ResolvedTypeXConfig = {
+    enabled: boolean;
+    dmPolicy: DmPolicy;
+    groupPolicy: GroupPolicy;
+    allowFrom: string[];
+    groupAllowFrom: string[];
+    historyLimit: number;
+    dmHistoryLimit: number;
+    textChunkLimit: number;
+    chunkMode: "length" | "newline";
+    blockStreaming: boolean;
+    streaming: boolean;
+    mediaMaxMb: number;
+    groups: Record<string, TypeXGroupConfig>;
+};
+/**
+ * Resolve effective TypeX configuration for an account.
+ * Account-level config overrides top-level typex config, which overrides channel defaults.
+ */
+export declare function resolveTypeXConfig(params: {
+    cfg: OpenClawConfig;
+    accountId?: string;
+}): ResolvedTypeXConfig;

package/dist/client/config.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTypeXConfig = resolveTypeXConfig;
+const firstDefined = (...values) => {
+    for (const value of values) {
+        if (typeof value !== "undefined") {
+            return value;
+        }
+    }
+    return undefined;
+};
+/**
+ * Resolve effective TypeX configuration for an account.
+ * Account-level config overrides top-level typex config, which overrides channel defaults.
+ */
+function resolveTypeXConfig(params) {
+    const { cfg, accountId } = params;
+    const typexCfg = cfg.channels?.typex;
+    const accountCfg = accountId ? typexCfg?.accounts?.[accountId] : undefined;
+    const defaults = cfg.channels?.defaults;
+    return {
+        enabled: firstDefined(accountCfg?.enabled, typexCfg?.enabled, true) ?? true,
+        dmPolicy: firstDefined(accountCfg?.dmPolicy, typexCfg?.dmPolicy) ?? "pairing",
+        groupPolicy: firstDefined(accountCfg?.groupPolicy, typexCfg?.groupPolicy, defaults?.groupPolicy) ?? "open",
+        allowFrom: (accountCfg?.allowFrom ?? typexCfg?.allowFrom ?? []).map(String),
+        groupAllowFrom: (accountCfg?.groupAllowFrom ?? typexCfg?.groupAllowFrom ?? []).map(String),
+        historyLimit: firstDefined(accountCfg?.historyLimit, typexCfg?.historyLimit) ?? 10,
+        dmHistoryLimit: firstDefined(accountCfg?.dmHistoryLimit, typexCfg?.dmHistoryLimit) ?? 20,
+        textChunkLimit: firstDefined(accountCfg?.textChunkLimit, typexCfg?.textChunkLimit) ?? 2000,
+        chunkMode: firstDefined(accountCfg?.chunkMode, typexCfg?.chunkMode) ?? "length",
+        blockStreaming: firstDefined(accountCfg?.blockStreaming, typexCfg?.blockStreaming) ?? true,
+        streaming: firstDefined(accountCfg?.streaming, typexCfg?.streaming) ?? true,
+        mediaMaxMb: firstDefined(accountCfg?.mediaMaxMb, typexCfg?.mediaMaxMb) ?? 30,
+        groups: { ...typexCfg?.groups, ...accountCfg?.groups },
+    };
+}

package/dist/client/message.d.ts

@@ -0,0 +1,15 @@
+import type { TypeXClient } from "./client.js";
+import type { TypeXMessageEntry } from "./types.js";
+import { OpenClawConfig } from "openclaw/plugin-sdk";
+export type ProcessTypeXMessageOptions = {
+    cfg?: OpenClawConfig;
+    accountId?: string;
+    botName?: string;
+    typexCfg?: Record<string, any>;
+    logger?: {
+        warn: (msg: string) => void;
+        info: (msg: string) => void;
+        error: (msg: string) => void;
+    } | undefined;
+};
+export declare function processTypeXMessage(client: TypeXClient, payload: TypeXMessageEntry, appId: string, options?: ProcessTypeXMessageOptions): Promise<void>;

package/dist/client/message.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTypeXMessage = processTypeXMessage;
+const send_js_1 = require("./send.js");
+const runtime_js_1 = require("./runtime.js");
+async function processTypeXMessage(client, payload, appId, options = {}) {
+    const cfg = options.typexCfg;
+    const accountId = options.accountId ?? appId;
+    const logger = options.logger;
+    const runtime = (0, runtime_js_1.getTypeXRuntime)();
+    const channel = runtime.channel;
+    if (!channel?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
+        logger?.error(`[typex:${accountId}] dispatchReplyWithBufferedBlockDispatcher not available`);
+        return;
+    }
+    if (!payload || !payload.chat_id) {
+        logger?.warn("Received invalid event payload");
+        return;
+    }
+    const chatId = payload.chat_id;
+    const senderId = payload.sender_id;
+    // Use content as text for now. If content is JSON string, parse it.
+    let text = payload.content.text;
+    // Attempt simple parsing if it looks like JSON? For now assume plain text or handle in future.
+    // Basic logging
+    logger?.info(`Processing TypeX message from ${senderId} in ${chatId}`);
+    // Build Context for Agent
+    const ctx = {
+        Body: text,
+        RawBody: text,
+        From: senderId,
+        To: chatId,
+        SenderId: senderId,
+        SenderName: payload.sender_name || "User",
+        ChatType: "dm", // Simplified, TypeX mostly DM for now?
+        Provider: "typex",
+        Surface: "typex",
+        Timestamp: payload.create_time || Date.now(),
+        MessageSid: payload.message_id,
+        AccountId: accountId,
+        OriginatingChannel: "typex",
+        OriginatingTo: chatId,
+    };
+    // Dispatch to Agent
+    await channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx,
+        cfg,
+        dispatcherOptions: {
+            channel: "typex",
+            accountId,
+            deliver: async (payload) => {
+                const responsePayload = payload;
+                // Handle text response
+                if (responsePayload.text) {
+                    await (0, send_js_1.sendMessageTypeX)(client, responsePayload.text);
+                }
+                // Handle media if present in response
+                const mediaUrls = responsePayload.mediaUrls?.length
+                    ? responsePayload.mediaUrls
+                    : responsePayload.mediaUrl
+                        ? [responsePayload.mediaUrl]
+                        : [];
+                for (const mediaUrl of mediaUrls) {
+                    await (0, send_js_1.sendMessageTypeX)(client, {}, { mediaUrl });
+                }
+            },
+            onError: (err) => {
+                logger?.error(`Reply dispatch error: ${err.message}`);
+            },
+        },
+        replyOptions: {
+            disableBlockStreaming: true,
+        },
+    });
+}

package/dist/client/monitor.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeEnv } from "openclaw/plugin-sdk";
+export type MonitorTypeXOpts = {
+    account: unknown;
+    runtime: RuntimeEnv;
+    abortSignal: AbortSignal;
+    log?: unknown;
+    typexCfg: Record<string, any>;
+};
+export declare function monitorTypeXProvider(opts: MonitorTypeXOpts): Promise<void>;

package/dist/client/monitor.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.monitorTypeXProvider = monitorTypeXProvider;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const client_js_1 = require("./client.js");
+const message_js_1 = require("./message.js");
+async function monitorTypeXProvider(opts) {
+    try {
+        const { account, runtime, abortSignal, log, typexCfg } = opts;
+        const accountObj = account;
+        const { email, token, appId } = accountObj.config;
+        // log is unknown, cast for usage
+        const logger = log;
+        if (!token) {
+            logger?.warn(`[${accountObj.accountId}] No token found. Stopping monitor.`);
+            return;
+        }
+        // Initialize Client
+        const client = (0, client_js_1.getTypeXClient)(undefined, { token, skipConfigCheck: true });
+        logger?.info(`[${accountObj.accountId}] Starting TypeX monitor for ${email || accountObj.accountId}...`);
+        const dataDir = runtime.dirs?.data || "./";
+        const safeId = (email || accountObj.accountId || "default").replace(/[^a-z0-9]/gi, "_");
+        const stateFile = path.join(dataDir, `.typex_pos_${safeId}.json`);
+        let currentPos = 0;
+        try {
+            const data = await fs.readFile(stateFile, "utf-8");
+            const json = JSON.parse(data);
+            if (typeof json.pos === "number") {
+                currentPos = json.pos;
+            }
+        }
+        catch {
+            /* Ignore */
+        }
+        // --- Polling Loop ---
+        while (!abortSignal.aborted) {
+            try {
+                const messages = await client.fetchMessages(currentPos);
+                if (messages && messages.length > 0) {
+                    for (const msg of messages) {
+                        // Dispatch to OpenClaw via processTypeXMessage
+                        await (0, message_js_1.processTypeXMessage)(client, msg, appId || accountObj.accountId, {
+                            accountId: accountObj.accountId,
+                            typexCfg,
+                            botName: accountObj.name,
+                            logger
+                        });
+                        if (typeof msg.position === "number") {
+                            currentPos = msg.position;
+                        }
+                    }
+                    // Save message position
+                    await fs.writeFile(stateFile, JSON.stringify({ pos: currentPos }));
+                }
+            }
+            catch (err) {
+                logger?.error(`Error in TypeX polling loop: ${err instanceof Error ? err.stack : String(err)}`);
+            }
+            if (abortSignal.aborted) {
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+            logger?.info(`Stopping TypeX monitor...`);
+        }
+    }
+    catch (e) {
+        throw e;
+    }
+}

package/dist/client/outbound.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+export declare const typexOutbound: ChannelOutboundAdapter;

package/dist/client/outbound.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typexOutbound = void 0;
+const client_js_1 = require("./client.js");
+const send_js_1 = require("./send.js");
+exports.typexOutbound = {
+    deliveryMode: "direct",
+    // chunker: ... (optional, default might be used or I can skip for MVP)
+    chunkerMode: "markdown",
+    textChunkLimit: 2000,
+    sendText: async ({ to, text, accountId }) => {
+        const client = (0, client_js_1.getTypeXClient)(accountId ?? undefined);
+        const result = await (0, send_js_1.sendMessageTypeX)(client, { text });
+        return {
+            channel: "typex",
+            messageId: result?.message_id || "unknown",
+            chatId: to,
+        };
+    },
+    sendMedia: async ({ to, text, mediaUrl, accountId }) => {
+        const client = (0, client_js_1.getTypeXClient)(accountId ?? undefined);
+        const result = await (0, send_js_1.sendMessageTypeX)(client, { text: text || "" }, { mediaUrl });
+        return {
+            channel: "typex",
+            messageId: result?.message_id || "unknown",
+            chatId: to,
+        };
+    },
+};

package/dist/client/runtime.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Global runtime reference for the TypeX plugin.
+ */
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+export declare function setTypeXRuntime(next: PluginRuntime): void;
+export declare function getTypeXRuntime(): PluginRuntime;