openclaw-extension-typex 1.0.19 → 1.0.21

package/dist/directory.d.ts

@@ -0,0 +1,24 @@
+type DirectoryEntry = {
+    kind: "user" | "group" | "channel";
+    id: string;
+    name?: string;
+    raw?: unknown;
+};
+export declare const typexDirectory: {
+    self: () => Promise<null>;
+    listPeers: ({ cfg, accountId, query, limit }: any) => Promise<DirectoryEntry[]>;
+    listGroups: ({ cfg, accountId, query, limit }: any) => Promise<{
+        kind: "group";
+        id: string;
+        name: string;
+        raw: any;
+    }[]>;
+    listPeersLive: (params: any) => Promise<DirectoryEntry[]>;
+    listGroupsLive: (params: any) => Promise<{
+        kind: "group";
+        id: string;
+        name: string;
+        raw: any;
+    }[]>;
+};
+export {};

package/dist/directory.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typexDirectory = void 0;
+const account_id_1 = require("openclaw/plugin-sdk/account-id");
+const client_js_1 = require("./client/client.js");
+function normalizeQuery(value) {
+    return (value ?? "").trim().toLowerCase();
+}
+function normalizeNameKey(value) {
+    return normalizeQuery(value).replace(/\s+/g, "");
+}
+function resolveClient(accountId, cfg) {
+    const typexCfg = (cfg.channels?.["openclaw-extension-typex"] ?? {});
+    const client = (0, client_js_1.getTypeXClient)(accountId ?? undefined, { typexCfg });
+    return { client, typexCfg };
+}
+exports.typexDirectory = {
+    self: async () => null,
+    listPeers: async ({ cfg, accountId, query, limit }) => {
+        const { client, typexCfg } = resolveClient(accountId, cfg);
+        const resolvedAccountId = accountId ?? account_id_1.DEFAULT_ACCOUNT_ID;
+        const account = typexCfg.accounts?.[resolvedAccountId];
+        const allowFrom = account?.allowFrom ?? typexCfg.allowFrom ?? [];
+        const q = normalizeQuery(query);
+        const max = limit && limit > 0 ? limit : undefined;
+        const configPeers = Array.from(new Set(allowFrom
+            .map((entry) => String(entry).trim())
+            .filter((entry) => entry && entry !== "*")
+            .map((entry) => entry.replace(/^typex:/i, ""))))
+            .filter((id) => (!q ? true : id.toLowerCase().includes(q)))
+            .map((id) => ({ kind: "user", id: `user:${id}`, name: id }));
+        if (!q)
+            return configPeers.slice(0, max);
+        try {
+            if (client.mode === "bot")
+                return configPeers.slice(0, max);
+            const [feeds, contacts] = await Promise.all([
+                client.fetchFeedsByName(q),
+                client.fetchContactsByName(q),
+            ]);
+            const contactEntries = contacts.map((contact) => ({
+                kind: "user",
+                id: `user:${contact.friend_id ?? contact.id}`,
+                name: String(contact.name ?? contact.alias ?? contact.friend_id ?? contact.id),
+                raw: contact,
+            }));
+            const seenContactNames = new Set(contactEntries.map((entry) => normalizeNameKey(entry.name)));
+            const feedEntries = feeds
+                .filter((feed) => {
+                const feedName = normalizeNameKey(feed.name ?? "");
+                return feed.chat_id && (!feedName || !seenContactNames.has(feedName));
+            })
+                .map((feed) => ({
+                kind: "user",
+                id: `chat:${feed.chat_id}`,
+                name: String(feed.name ?? feed.chat_id),
+                raw: feed,
+            }));
+            const all = [...configPeers, ...contactEntries, ...feedEntries];
+            const unique = Array.from(new Map(all.map((entry) => [entry.id, entry])).values());
+            return unique.slice(0, max);
+        }
+        catch (error) {
+            console.error("Failed to fetch peers from TypeX directory", error);
+            return configPeers.slice(0, max);
+        }
+    },
+    listGroups: async ({ cfg, accountId, query, limit }) => {
+        const { client } = resolveClient(accountId, cfg);
+        const q = normalizeQuery(query);
+        const max = limit && limit > 0 ? limit : undefined;
+        if (!q || client.mode !== "user")
+            return [];
+        try {
+            const feeds = await client.fetchFeedsByName(q);
+            const groups = feeds
+                .filter((feed) => Boolean(feed.chat_id))
+                .map((feed) => ({
+                kind: "group",
+                id: `chat:${feed.chat_id}`,
+                name: String(feed.name ?? feed.chat_id),
+                raw: feed,
+            }))
+                .slice(0, max);
+            return groups;
+        }
+        catch (error) {
+            console.error("Failed to fetch groups from TypeX directory", error);
+            return [];
+        }
+    },
+    listPeersLive: async (params) => exports.typexDirectory.listPeers(params),
+    listGroupsLive: async (params) => exports.typexDirectory.listGroups(params),
+};

package/dist/index.d.ts

@@ -1,140 +1,188 @@
 import { normalizeTypeXTarget } from "./normalize.js";
-import { OpenClawPluginApi } from "openclaw/plugin-sdk";
-declare const plugin: {
-    messaging: {
-        normalizeTarget: typeof normalizeTypeXTarget;
-        targetResolver: {
-            looksLikeId: () => boolean;
-            hint: string;
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: import("../node_modules/openclaw/dist/plugin-sdk/src/channels/plugins/types.plugin.js", { with: { "resolution-mode": "import" } }).ChannelConfigSchema;
+    register: (api: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawPluginApi) => void;
+    channelPlugin: {
+        messaging: {
+            normalizeTarget: typeof normalizeTypeXTarget;
+            targetResolver: {
+                looksLikeId: (raw: string) => boolean;
+                hint: string;
+            };
         };
-    };
-    register(api: OpenClawPluginApi): void;
-    id: "openclaw-extension-typex";
-    meta: {
         id: string;
-        label: string;
-        selectionLabel: string;
-        detailLabel: string;
-        docsPath: string;
-        docsLabel: string;
-        blurb: string;
-        order: number;
-    };
-    onboarding: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).ChannelOnboardingAdapter;
-    capabilities: {
-        chatTypes: ("group" | "direct")[];
-        media: true;
-        reactions: false;
-        threads: false;
-        polls: false;
-        nativeCommands: false;
-        blockStreaming: false;
-    };
-    reload: {
-        configPrefixes: string[];
-    };
-    outbound: any;
-    configSchema: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).ChannelConfigSchema;
-    config: {
-        listAccountIds: (cfg: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).OpenClawConfig) => string[];
-        resolveAccount: (cfg: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).OpenClawConfig, accountId: string | null | undefined) => {
-            accountId: string;
-            name: any;
-            enabled: boolean;
-            configured: boolean;
-            tokenSource: string;
-            config: any;
+        meta: {
+            id: string;
+            label: string;
+            selectionLabel: string;
+            detailLabel: string;
+            docsPath: string;
+            docsLabel: string;
+            blurb: string;
+            order: number;
+            showInSetup: boolean;
+            exposure: {
+                setup: boolean;
+                docs: boolean;
+                configured: boolean;
+            };
         };
-        defaultAccountId: (cfg: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).OpenClawConfig) => string;
-        setAccountEnabled: ({ cfg }: {
-            cfg: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).OpenClawConfig;
-            accountId: string;
-            enabled: boolean;
-        }) => import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).OpenClawConfig;
-        deleteAccount: ({ cfg }: {
-            cfg: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).OpenClawConfig;
-            accountId: string;
-        }) => import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).OpenClawConfig;
-        isConfigured: (acc: any) => any;
-        describeAccount: (acc: any) => {
-            accountId: any;
-            name: any;
-            enabled: any;
-            configured: any;
-            tokenSource: any;
+        setupWizard: import("openclaw/plugin-sdk/setup", { with: { "resolution-mode": "import" } }).ChannelSetupWizardAdapter;
+        capabilities: {
+            chatTypes: ("group" | "direct")[];
+            media: true;
+            reactions: false;
+            threads: false;
+            polls: false;
+            nativeCommands: false;
+            blockStreaming: true;
         };
-        resolveAllowFrom: () => never[];
-        formatAllowFrom: () => never[];
-    };
-    gateway: {
-        startAccount: (ctx: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).ChannelGatewayContext<any>) => Promise<void>;
-    };
-    security: {
-        resolveDmPolicy: () => {
-            policy: string;
-            allowFrom: never[];
-            policyPath: string;
-            allowFromPath: string;
-            approveHint: string;
-            normalizeEntry: (s: string) => string;
+        agentPrompt: {
+            messageToolHints: () => string[];
         };
-    };
-    groups: {
-        resolveRequireMention: ({ cfg, groupId }: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).ChannelGroupContext) => any;
-    };
-    directory: {
-        self: () => Promise<null>;
-        listPeers: () => Promise<never[]>;
-        listGroups: () => Promise<never[]>;
-    };
-    status: {
-        defaultRuntime: {
-            accountId: string;
-            running: false;
-            lastStartAt: null;
-            lastStopAt: null;
-            lastError: null;
+        agentTools: ({ cfg }: {
+            cfg?: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig;
+        }) => import("openclaw/plugin-sdk/channel-contract", { with: { "resolution-mode": "import" } }).ChannelAgentTool[];
+        actions: import("openclaw/plugin-sdk/channel-contract", { with: { "resolution-mode": "import" } }).ChannelMessageActionAdapter;
+        reload: {
+            configPrefixes: string[];
+        };
+        outbound: any;
+        configSchema: import("../node_modules/openclaw/dist/plugin-sdk/src/channels/plugins/types.plugin.js", { with: { "resolution-mode": "import" } }).ChannelConfigSchema;
+        config: {
+            listAccountIds: (cfg: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig) => string[];
+            resolveAccount: (cfg: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig, accountId: string | null | undefined) => {
+                accountId: string;
+                name: any;
+                enabled: boolean;
+                configured: boolean;
+                tokenSource: string;
+                config: any;
+            };
+            defaultAccountId: (cfg: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig) => string;
+            setAccountEnabled: ({ cfg }: {
+                cfg: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig;
+                accountId: string;
+                enabled: boolean;
+            }) => import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig;
+            deleteAccount: ({ cfg }: {
+                cfg: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig;
+                accountId: string;
+            }) => import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig;
+            isConfigured: (acc: any) => any;
+            describeAccount: (acc: any) => {
+                accountId: any;
+                name: any;
+                enabled: any;
+                configured: any;
+                tokenSource: any;
+            };
+            resolveAllowFrom: ({ cfg, accountId }: {
+                cfg: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig;
+                accountId?: string | null;
+            }) => any;
+            formatAllowFrom: ({ allowFrom }: {
+                cfg: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig;
+                accountId?: string | null;
+                allowFrom: Array<string | number>;
+            }) => string[];
+        };
+        gateway: {
+            startAccount: (ctx: import("openclaw/plugin-sdk/channel-contract", { with: { "resolution-mode": "import" } }).ChannelGatewayContext<any>) => Promise<void>;
+        };
+        security: {
+            resolveDmPolicy: () => {
+                policy: string;
+                allowFrom: never[];
+                policyPath: string;
+                allowFromPath: string;
+                approveHint: string;
+                normalizeEntry: (s: string) => string;
+            };
+        };
+        groups: {
+            resolveRequireMention: ({ cfg, groupId }: import("openclaw/plugin-sdk/channel-contract", { with: { "resolution-mode": "import" } }).ChannelGroupContext) => any;
+        };
+        directory: {
+            self: () => Promise<null>;
+            listPeers: ({ cfg, accountId, query, limit }: any) => Promise<{
+                kind: "user" | "group" | "channel";
+                id: string;
+                name?: string;
+                raw?: unknown;
+            }[]>;
+            listGroups: ({ cfg, accountId, query, limit }: any) => Promise<{
+                kind: "group";
+                id: string;
+                name: string;
+                raw: any;
+            }[]>;
+            listPeersLive: (params: any) => Promise<{
+                kind: "user" | "group" | "channel";
+                id: string;
+                name?: string;
+                raw?: unknown;
+            }[]>;
+            listGroupsLive: (params: any) => Promise<{
+                kind: "group";
+                id: string;
+                name: string;
+                raw: any;
+            }[]>;
         };
-        collectStatusIssues: () => never[];
-        buildChannelSummary: ({ snapshot }: {
-            account: any;
-            cfg: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).OpenClawConfig;
-            defaultAccountId: string;
-            snapshot: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).ChannelAccountSnapshot;
-        }) => Promise<{
-            configured: boolean | undefined;
-            tokenSource: string | undefined;
-            running: boolean | undefined;
-            lastStartAt: number | null | undefined;
-            lastStopAt: number | null | undefined;
-            lastError: string | null | undefined;
-            probe: unknown;
-            lastProbeAt: number | null | undefined;
-        }>;
-        probeAccount: () => Promise<{
-            ok: boolean;
-            timestamp: number;
-        }>;
-        buildAccountSnapshot: ({ account, runtime }: {
-            account: any;
-            cfg: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).OpenClawConfig;
-            runtime?: import("openclaw/plugin-sdk", { with: { "resolution-mode": "import" } }).ChannelAccountSnapshot;
-            probe?: unknown;
-            audit?: unknown;
-        }) => {
-            accountId: any;
-            name: any;
-            enabled: any;
-            configured: any;
-            tokenSource: any;
-            running: boolean;
-            lastStartAt: number | null;
-            lastStopAt: number | null;
-            lastError: string | null;
-            lastInboundAt: null;
-            lastOutboundAt: null;
+        status: {
+            defaultRuntime: {
+                accountId: string;
+                running: false;
+                lastStartAt: null;
+                lastStopAt: null;
+                lastError: null;
+            };
+            collectStatusIssues: () => never[];
+            buildChannelSummary: ({ snapshot }: {
+                account: any;
+                cfg: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig;
+                defaultAccountId: string;
+                snapshot: import("openclaw/plugin-sdk/channel-contract", { with: { "resolution-mode": "import" } }).ChannelAccountSnapshot;
+            }) => Promise<{
+                configured: boolean | undefined;
+                tokenSource: string | undefined;
+                running: boolean | undefined;
+                lastStartAt: number | null | undefined;
+                lastStopAt: number | null | undefined;
+                lastError: string | null | undefined;
+                probe: unknown;
+                lastProbeAt: number | null | undefined;
+            }>;
+            probeAccount: () => Promise<{
+                ok: boolean;
+                timestamp: number;
+            }>;
+            buildAccountSnapshot: ({ account, runtime }: {
+                account: any;
+                cfg: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).OpenClawConfig;
+                runtime?: import("openclaw/plugin-sdk/channel-contract", { with: { "resolution-mode": "import" } }).ChannelAccountSnapshot;
+                probe?: unknown;
+                audit?: unknown;
+            }) => {
+                accountId: any;
+                name: any;
+                enabled: any;
+                configured: any;
+                tokenSource: any;
+                running: boolean;
+                lastStartAt: number | null;
+                lastStopAt: number | null;
+                lastError: string | null;
+                lastInboundAt: null;
+                lastOutboundAt: null;
+            };
+            logSelfId: () => void;
         };
-        logSelfId: () => void;
     };
+    setChannelRuntime?: (runtime: import("openclaw/plugin-sdk/channel-core", { with: { "resolution-mode": "import" } }).PluginRuntime) => void;
 };
-export = plugin;
+export default _default;

package/dist/index.js

@@ -1,4 +1,6 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const channel_core_1 = require("openclaw/plugin-sdk/channel-core");
 const plugin_js_1 = require("./plugin.js");
 const normalize_js_1 = require("./normalize.js");
 const runtime_js_1 = require("./client/runtime.js");
@@ -6,14 +8,13 @@ const plugin = {
     ...plugin_js_1.typexPlugin,
     messaging: {
         normalizeTarget: normalize_js_1.normalizeTypeXTarget,
-        targetResolver: {
-            looksLikeId: () => true,
-            hint: "chat_id",
-        },
-    },
-    register(api) {
-        (0, runtime_js_1.setTypeXRuntime)(api.runtime);
-        api.registerChannel(plugin_js_1.typexPlugin);
+        targetResolver: plugin_js_1.typexPlugin.messaging.targetResolver,
     },
 };
-module.exports = plugin;
+exports.default = (0, channel_core_1.defineChannelPluginEntry)({
+    id: plugin.id,
+    name: plugin.meta.label,
+    description: plugin.meta.blurb,
+    plugin,
+    setRuntime: runtime_js_1.setTypeXRuntime,
+});

package/dist/normalize.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeTypeXTarget = normalizeTypeXTarget;
 function normalizeTypeXTarget(raw) {
-    let normalized = raw.replace(/^typex:/i, "").trim();
-    normalized = normalized.replace(/^(group|chat|user|dm):/i, "").trim();
+    const normalized = raw.replace(/^typex:/i, "").trim();
+    if (!normalized) {
+        return normalized;
+    }
+    if (/^dm:/i.test(normalized)) {
+        return `user:${normalized.slice(3).trim()}`;
+    }
     return normalized;
 }

package/dist/onboarding.d.ts

@@ -1,2 +1,2 @@
-import type { ChannelOnboardingAdapter } from "openclaw/plugin-sdk";
-export declare const typexOnboardingAdapter: ChannelOnboardingAdapter;
+import type { ChannelSetupWizardAdapter } from "openclaw/plugin-sdk/setup";
+export declare const typexSetupWizard: ChannelSetupWizardAdapter;

package/dist/onboarding.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typexOnboardingAdapter = void 0;
+exports.typexSetupWizard = void 0;
 const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
 const accounts_js_1 = require("./client/accounts.js");
 const client_js_1 = require("./client/client.js");
@@ -19,7 +19,7 @@ function extractQrCodeId(qrcodeData) {
         return new URLSearchParams(queryOnly).get("qr_code_id") || "";
     }
 }
-exports.typexOnboardingAdapter = {
+exports.typexSetupWizard = {
     channel: CHANNEL_ID,
     getStatus: async ({ cfg }) => {
         const accountId = (0, accounts_js_1.resolveDefaultTypeXAccountId)(cfg);