@ascegu/teamily 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ascegu/teamily",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "OpenClaw Teamily channel plugin - Team instant messaging server integration",
   "type": "module",
   "main": "index.ts",
@@ -8,6 +8,7 @@
     "*.ts",
     "*.js",
     "*.json",
+    "src/",
     "README.md"
   ],
   "keywords": [

package/src/accounts.ts

@@ -0,0 +1,51 @@
+import type { CoreConfig } from "./config-schema.js";
+import type { ResolvedTeamilyAccount } from "./types.js";
+
+export function listTeamilyAccountIds(cfg: CoreConfig): string[] {
+  const config = cfg.channels?.teamily;
+  if (!config?.enabled || !config.accounts) {
+    return [];
+  }
+  return Object.keys(config.accounts).filter(
+    (key) => config.accounts![key].token !== undefined
+  );
+}
+
+export function resolveDefaultTeamilyAccountId(cfg: CoreConfig): string {
+  const accountIds = listTeamilyAccountIds(cfg);
+  return accountIds[0] || "default";
+}
+
+export function resolveTeamilyAccount(
+  cfg: CoreConfig,
+  accountId?: string | null
+): ResolvedTeamilyAccount {
+  const config = cfg.channels?.teamily;
+  if (!config?.enabled) {
+    throw new Error("Teamily channel is not enabled");
+  }
+
+  const accountIds = listTeamilyAccountIds(cfg);
+  const targetAccountId = accountId || accountIds[0];
+
+  if (!targetAccountId) {
+    throw new Error("No Teamily account configured");
+  }
+
+  const account = config.accounts?.[targetAccountId];
+  if (!account) {
+    throw new Error(`Teamily account ${targetAccountId} not found`);
+  }
+
+  return {
+    accountId: targetAccountId,
+    enabled: true,
+    platformUrl: config.server.platformUrl,
+    apiURL: config.server.apiURL,
+    wsURL: config.server.wsURL,
+    userID: account.userID,
+    token: account.token,
+    nickname: account.nickname,
+    faceURL: account.faceURL,
+  };
+}

package/src/channel.ts

@@ -0,0 +1,411 @@
+import {
+  applyAccountNameToChannelSection,
+  buildChannelConfigSchema,
+  DEFAULT_ACCOUNT_ID,
+  deleteAccountFromConfigSection,
+  formatPairingApproveHint,
+  normalizeAccountId,
+  PAIRING_APPROVED_MESSAGE,
+  setAccountEnabledInConfigSection,
+  type ChannelPlugin,
+  type ChannelOutboundContext,
+  type ChannelOutboundAdapter,
+  type ChannelStatusAdapter,
+  type ChannelStatusIssue,
+} from "openclaw/plugin-sdk";
+import { TeamilyConfigSchema } from "./config-schema.js";
+import {
+  listTeamilyAccountIds,
+  resolveDefaultTeamilyAccountId,
+  resolveTeamilyAccount,
+  type ResolvedTeamilyAccount,
+} from "./accounts.js";
+import { probeTeamily } from "./probe.js";
+import { sendMessageTeamily, sendMediaTeamily } from "./send.js";
+import { startTeamilyMonitoring, stopTeamilyMonitoring } from "./monitor.js";
+import { normalizeTeamilyTarget, normalizeTeamilyAllowEntry } from "./normalize.js";
+import { SESSION_TYPES } from "./types.js";
+import { getTeamilyRuntime } from "./runtime.js";
+import type { CoreConfig } from "./config-schema.js";
+
+const meta = {
+  id: "teamily",
+  label: "Teamily",
+  selectionLabel: "Teamily (self-hosted)",
+  docsPath: "/channels/teamily",
+  docsLabel: "teamily",
+  blurb: "Team instant messaging server",
+  order: 75,
+  quickstartAllowFrom: true,
+};
+
+const capabilities = {
+  chatTypes: ["direct", "group"] as const,
+  media: true,
+  reactions: true,
+  threads: false,
+  polls: false,
+  streaming: false,
+};
+
+export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
+  id: "teamily",
+  meta,
+  capabilities,
+  onboarding: {
+    promptAccountId,
+    resolveAccountId,
+    applyAccountName: ({ cfg, accountId, name }) =>
+      applyAccountNameToChannelSection({
+        cfg: cfg as CoreConfig,
+        sectionKey: "teamily",
+        accountId,
+        name,
+        allowTopLevel: true,
+      }),
+    applyAccountConfig: ({ cfg, accountId, input }) =>
+      applyTeamilyAccountConfig({ cfg: cfg as CoreConfig, accountId, input }),
+    resolveBindingAccountId: ({ cfg }) => resolveDefaultTeamilyAccountId(cfg as CoreConfig),
+  },
+  pairing: {
+    idLabel: "teamilyUserId",
+    normalizeAllowEntry: (entry) => {
+      try {
+        return normalizeTeamilyAllowEntry(entry);
+      } catch {
+        return entry;
+      }
+    },
+    notifyApproval: async ({ id, cfg }) => {
+      try {
+        const accountId = resolveDefaultTeamilyAccountId(cfg as CoreConfig);
+        const account = resolveTeamilyAccount(cfg as CoreConfig, accountId);
+        const target = normalizeTeamilyTarget(id);
+        await sendMessageTeamily({
+          account,
+          target,
+          text: PAIRING_APPROVED_MESSAGE,
+        });
+      } catch {
+        // Silently fail on notification
+      }
+    },
+  },
+  configSchema: buildChannelConfigSchema(TeamilyConfigSchema),
+  config: {
+    listAccountIds: (cfg) => listTeamilyAccountIds(cfg as CoreConfig),
+    resolveAccount: (cfg, accountId) =>
+      resolveTeamilyAccount(cfg as CoreConfig, accountId),
+    defaultAccountId: (cfg) => resolveDefaultTeamilyAccountId(cfg as CoreConfig),
+    setAccountEnabled: ({ cfg, accountId, enabled }) =>
+      setAccountEnabledInConfigSection({
+        cfg: cfg as CoreConfig,
+        sectionKey: "teamily",
+        accountId,
+        enabled,
+        allowTopLevel: true,
+      }),
+    deleteAccount: ({ cfg, accountId }) =>
+      deleteAccountFromConfigSection({
+        cfg: cfg as CoreConfig,
+        sectionKey: "teamily",
+        accountId,
+        clearBaseFields: [
+          "name",
+          "userID",
+          "token",
+          "nickname",
+          "faceURL",
+        ],
+      }),
+    isConfigured: (account) => !!account.token,
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      name: account.nickname || account.userID,
+      enabled: account.enabled,
+      configured: !!account.token,
+    }),
+    resolveAllowFrom: (cfg, accountId) => {
+      // Return empty array - allowFrom needs to be manually configured
+      return [];
+    },
+    formatAllowFrom: (cfg, allowFrom) => {
+      return allowFrom.map((id) => id.toString());
+    },
+    resolveDefaultTo: (cfg) => {
+      // No default target - user must specify
+      return undefined;
+    },
+  },
+  outbound: {
+    sendText: async (ctx: ChannelOutboundContext) => {
+      const { to, text, accountId } = ctx;
+      const account = resolveTeamilyAccount(ctx.cfg, accountId);
+      const target = normalizeTeamilyTarget(to);
+
+      const result = await sendMessageTeamily({
+        account,
+        target,
+        text,
+        replyToId: ctx.replyToId || undefined,
+      });
+
+      if (!result.success) {
+        throw new Error(result.error || "Failed to send message");
+      }
+
+      return { messageId: result.messageId };
+    },
+    sendMedia: async (ctx: ChannelOutboundContext) => {
+      const { to, mediaUrl, text, accountId } = ctx;
+      const account = resolveTeamilyAccount(ctx.cfg, accountId);
+      const target = normalizeTeamilyTarget(to);
+
+      // Determine media type from URL or assume image
+      let mediaType: "image" | "video" | "audio" | "file" = "image";
+      const urlLower = mediaUrl.toLowerCase();
+      if (urlLower.endsWith(".mp4") || urlLower.endsWith(".mov") || urlLower.endsWith(".webm")) {
+        mediaType = "video";
+      } else if (urlLower.endsWith(".mp3") || urlLower.endsWith(".m4a") || urlLower.endsWith(".wav")) {
+        mediaType = "audio";
+      } else if (
+        urlLower.endsWith(".pdf") ||
+        urlLower.endsWith(".doc") ||
+        urlLower.endsWith(".docx") ||
+        urlLower.endsWith(".zip")
+      ) {
+        mediaType = "file";
+      }
+
+      const result = await sendMediaTeamily({
+        account,
+        target,
+        mediaUrl,
+        mediaType,
+        caption: text,
+      });
+
+      if (!result.success) {
+        throw new Error(result.error || "Failed to send media");
+      }
+
+      return { messageId: result.messageId };
+    },
+    resolveTarget: (raw) => {
+      return normalizeTeamilyTarget(raw).id;
+    },
+  },
+  status: {
+    probeAccount: async (cfg, accountId) => {
+      const account = resolveTeamilyAccount(cfg as CoreConfig, accountId);
+      const result = await probeTeamily(account);
+
+      if (!result.connected) {
+        return {
+          connected: false,
+          error: result.error || "Failed to connect to Teamily server",
+        };
+      }
+
+      return { connected: true };
+    },
+    buildAccountSnapshot: (cfg, accountId) => {
+      const account = resolveTeamilyAccount(cfg as CoreConfig, accountId);
+      return {
+        accountId,
+        name: account.nickname || account.userID,
+        enabled: account.enabled,
+        configured: !!account.token,
+      };
+    },
+    collectStatusIssues: async (cfg, accountId) => {
+      const issues: ChannelStatusIssue[] = [];
+      const account = resolveTeamilyAccount(cfg as CoreConfig, accountId);
+
+      if (!account.token) {
+        issues.push({
+          channel: "teamily",
+          accountId,
+          kind: "config",
+          message: "User token is not configured",
+          fix: "Run `openclaw channel configure teamily` to set up authentication",
+        });
+      }
+
+      if (!account.apiURL || account.apiURL === "http://localhost:10002") {
+        issues.push({
+          channel: "teamily",
+          accountId,
+          kind: "config",
+          message: "Teamily API URL is set to default localhost",
+          fix: "Update the API URL to your Teamily server address",
+        });
+      }
+
+      const probeResult = await probeTeamily(account);
+      if (!probeResult.connected) {
+        issues.push({
+          channel: "teamily",
+          accountId,
+          kind: "runtime",
+          message: probeResult.error || "Cannot connect to Teamily server",
+          fix: "Check that the Teamily server is running and accessible",
+        });
+      }
+
+      return issues;
+    },
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const { cfg, accountId, account, log } = ctx;
+
+      if (!account.token) {
+        log?.warn?.(`Teamily account ${accountId} not configured (missing token)`);
+        return { stop: () => {} };
+      }
+
+      log?.info?.(`Starting Teamily channel (account: ${accountId})`);
+
+      const stopFn = startTeamilyMonitoring(account, async (message) => {
+        const rt = getTeamilyRuntime();
+        const currentCfg = rt.config.loadConfig();
+
+        const isGroup = message.sessionType === SESSION_TYPES.GROUP;
+        const from = message.sendID;
+        const text = message.content?.text || "";
+        const sessionKey = isGroup ? `teamily:group:${message.recvID}` : `teamily:${from}`;
+
+        let mediaUrl: string | undefined;
+        if (message.content?.picture?.sourcePicture?.url) {
+          mediaUrl = message.content.picture.sourcePicture.url;
+        } else if (message.content?.video?.videoUrl) {
+          mediaUrl = message.content.video.videoUrl;
+        } else if (message.content?.audio?.sourceUrl) {
+          mediaUrl = message.content.audio.sourceUrl;
+        }
+
+        const msgCtx = {
+          Body: text,
+          From: from,
+          To: account.userID,
+          SessionKey: sessionKey,
+          AccountId: accountId,
+          OriginatingChannel: "teamily" as any,
+          OriginatingTo: from,
+          ChatType: isGroup ? "group" : "direct",
+          MediaUrl: mediaUrl,
+        };
+
+        await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+          ctx: msgCtx,
+          cfg: currentCfg,
+          dispatcherOptions: {
+            deliver: async (payload: { text?: string; body?: string }) => {
+              const replyText = payload?.text ?? payload?.body;
+              if (replyText) {
+                const target = normalizeTeamilyTarget(from);
+                await sendMessageTeamily({ account, target, text: replyText });
+              }
+            },
+            onReplyStart: () => {
+              log?.info?.(`Agent reply started for ${from}`);
+            },
+          },
+        });
+      });
+
+      // Respect abort signal from the gateway framework
+      ctx.abortSignal.addEventListener("abort", () => {
+        stopFn();
+        stopTeamilyMonitoring(accountId);
+      });
+
+      // Return a promise that never resolves (monitor runs indefinitely)
+      return new Promise<void>(() => {});
+    },
+  },
+};
+
+/**
+ * Normalize account ID for Teamily.
+ */
+function promptAccountId(): string {
+  return DEFAULT_ACCOUNT_ID;
+}
+
+function resolveAccountId(params: {
+  cfg: CoreConfig;
+  accountId?: string;
+  input?: { name?: string };
+}): string {
+  const { cfg, accountId, input } = params;
+  if (accountId) {
+    return accountId;
+  }
+  if (input?.name) {
+    return normalizeAccountId(input.name);
+  }
+  const accountIds = listTeamilyAccountIds(cfg);
+  return accountIds[0] || DEFAULT_ACCOUNT_ID;
+}
+
+/**
+ * Apply Teamily account configuration.
+ */
+function applyTeamilyAccountConfig(params: {
+  cfg: CoreConfig;
+  accountId: string;
+  input: Record<string, unknown>;
+}): CoreConfig {
+  const { cfg, accountId, input } = params;
+  const existing = cfg.channels?.teamily || { enabled: false, server: {}, accounts: {} };
+
+  const accountUpdate: Record<string, unknown> = {};
+  if (input.userID) {
+    accountUpdate.userID = String(input.userID);
+  }
+  if (input.token) {
+    accountUpdate.token = String(input.token);
+  }
+  if (input.nickname) {
+    accountUpdate.nickname = String(input.nickname);
+  }
+  if (input.faceURL) {
+    accountUpdate.faceURL = String(input.faceURL);
+  }
+
+  // Server configuration from input or existing
+  const serverUpdate: Record<string, unknown> = {};
+  if (input.platformUrl) {
+    serverUpdate.platformUrl = String(input.platformUrl);
+  }
+  if (input.apiURL) {
+    serverUpdate.apiURL = String(input.apiURL);
+  }
+  if (input.wsURL) {
+    serverUpdate.wsURL = String(input.wsURL);
+  }
+
+  return {
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      teamily: {
+        ...existing,
+        enabled: true,
+        server: {
+          ...existing.server,
+          ...serverUpdate,
+        },
+        accounts: {
+          ...existing.accounts,
+          [accountId]: {
+            ...(existing.accounts?.[accountId] || {}),
+            ...accountUpdate,
+          },
+        },
+      },
+    },
+  };
+}

package/src/config-schema.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import type { ChannelConfigSchema } from "openclaw/plugin-sdk";
+import { buildChannelConfigSchema } from "openclaw/plugin-sdk";
+import type { TeamilyConfig } from "./types.js";
+
+// Server configuration schema
+export const TeamilyServerConfigSchema = z.object({
+  platformUrl: z
+    .string()
+    .url()
+    .default("http://localhost:10002")
+    .describe("Teamily platform URL"),
+  apiURL: z
+    .string()
+    .url()
+    .default("http://localhost:10002")
+    .describe("Teamily REST API URL"),
+  wsURL: z
+    .string()
+    .url()
+    .default("ws://localhost:10001")
+    .describe("Teamily WebSocket URL"),
+});
+
+// User account configuration schema
+export const TeamilyUserAccountSchema = z.object({
+  userID: z
+    .string()
+    .min(1)
+    .describe("User ID for the bot account"),
+  token: z
+    .string()
+    .min(1)
+    .describe("User token for authentication"),
+  nickname: z
+    .string()
+    .optional()
+    .describe("Display nickname for the bot"),
+  faceURL: z
+    .string()
+    .url()
+    .optional()
+    .describe("Avatar URL for the bot"),
+});
+
+// Main Teamily configuration schema
+export const TeamilyConfigSchema = z.object({
+  enabled: z
+    .boolean()
+    .default(true)
+    .describe("Enable Teamily channel"),
+  server: TeamilyServerConfigSchema.describe("Teamily server configuration"),
+  accounts: z
+    .record(z.string(), TeamilyUserAccountSchema)
+    .default({})
+    .describe("Teamily bot accounts"),
+});
+
+export const TeamilyChannelConfigSchema = buildChannelConfigSchema(
+  TeamilyConfigSchema
+) as ChannelConfigSchema;
+
+export type CoreConfig = {
+  channels?: {
+    teamily?: TeamilyConfig;
+  };
+};