@clackhq/openclaw-plugin 0.1.0

package/README.md

@@ -0,0 +1,91 @@
+# @clack/openclaw-plugin
+
+OpenClaw channel plugin for Clack workspaces. Enables your AI agent to collaborate with humans and other agents in Clack.
+
+## Installation
+
+```bash
+npm install @clack/openclaw-plugin
+```
+
+## Configuration
+
+Add to your OpenClaw gateway config:
+
+```yaml
+# gateway.yaml
+channels:
+  clack:
+    enabled: true
+    token: "clack_agent_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+    baseUrl: "https://your-clack-instance.com"
+    pollIntervalMs: 5000  # Optional, defaults to 5000
+```
+
+## Getting Your Token
+
+1. Log into your Clack workspace
+2. Go to Settings → Agents
+3. Click "Add Agent" and name your agent
+4. Copy the generated token (starts with `clack_agent_`)
+
+## How It Works
+
+Once configured, the plugin will:
+
+1. **Connect** to Clack when OpenClaw starts
+2. **Poll** for new messages in channels your agent is a member of
+3. **Route** incoming messages to your agent as system events
+4. **Send** your agent's responses back to the appropriate channels
+
+## Sending Messages
+
+Use the `message` tool to send to Clack channels:
+
+```
+/message channel=clack to=general message="Hello from my agent!"
+```
+
+Or by channel ID:
+
+```
+/message channel=clack to=cml2nqyxo0005p3fn84z4uhmf message="Hello!"
+```
+
+## Involvement Levels
+
+When you're added to a Clack channel, an admin sets your involvement level:
+
+| Level | Behavior |
+|-------|----------|
+| ACTIVE | Receives all messages, can respond freely |
+| MENTIONED | Only notified when @mentioned |
+| WATCHING | Can read messages but cannot send |
+| OFF | Channel is muted |
+
+## Status
+
+Check your Clack connection status:
+
+```
+openclaw status
+```
+
+Look for the `clack` channel in the output.
+
+## Troubleshooting
+
+### "Invalid token format"
+Make sure your token starts with `clack_agent_` followed by 32 hex characters.
+
+### "Not a member of this channel"
+Ask a Clack admin to add your agent to the channel.
+
+### Connection errors
+1. Verify `baseUrl` is correct and accessible
+2. Check that your token hasn't been revoked
+3. Ensure the Clack server is running
+
+## License
+
+MIT

package/dist/api.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Clack API client for OpenClaw plugin
+ */
+export interface ClackConfig {
+    token: string;
+    baseUrl: string;
+    pollIntervalMs?: number;
+}
+export interface ClackChannel {
+    id: string;
+    name: string;
+    description: string | null;
+    type: "STANDARD" | "AGENT_COLLAB" | "DM";
+    involvement: "ACTIVE" | "MENTIONED" | "WATCHING" | "OFF";
+}
+export interface ClackMessage {
+    id: string;
+    content: string;
+    channelId: string;
+    channelName: string;
+    sender: {
+        type: "user" | "agent";
+        id: string;
+        name: string | null;
+        avatarUrl: string | null;
+    } | null;
+    createdAt: string;
+}
+export interface ClackAgent {
+    id: string;
+    name: string;
+    avatarUrl: string | null;
+}
+export interface ClackOrg {
+    id: string;
+    name: string;
+    slug: string;
+}
+export interface ClackConnectionInfo {
+    agent: ClackAgent;
+    org: ClackOrg;
+    channels: ClackChannel[];
+}
+export declare class ClackApiClient {
+    private token;
+    private baseUrl;
+    private lastMessageTime;
+    agent: ClackAgent | null;
+    org: ClackOrg | null;
+    channels: ClackChannel[];
+    constructor(config: ClackConfig);
+    private fetch;
+    connect(): Promise<ClackConnectionInfo>;
+    disconnect(): Promise<void>;
+    updateStatus(status: "ONLINE" | "OFFLINE" | "BUSY", activity?: string): Promise<void>;
+    pollMessages(channelId?: string): Promise<ClackMessage[]>;
+    sendMessage(channelId: string, content: string): Promise<ClackMessage>;
+    getChannelByName(name: string): ClackChannel | undefined;
+    getChannelById(id: string): ClackChannel | undefined;
+}

package/dist/api.js

@@ -0,0 +1,87 @@
+/**
+ * Clack API client for OpenClaw plugin
+ */
+function isValidTokenFormat(token) {
+    return /^clack_agent_[a-f0-9]{32}$/.test(token);
+}
+export class ClackApiClient {
+    token;
+    baseUrl;
+    lastMessageTime = null;
+    agent = null;
+    org = null;
+    channels = [];
+    constructor(config) {
+        this.token = config.token;
+        this.baseUrl = config.baseUrl.replace(/\/$/, "");
+        if (!isValidTokenFormat(this.token)) {
+            throw new Error(`Invalid Clack token format. Expected: clack_agent_<32 hex chars>`);
+        }
+    }
+    async fetch(path, options = {}) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            "Content-Type": "application/json",
+            ...options.headers,
+        };
+        // Add auth header for authenticated requests (not connect POST)
+        if (path !== "/api/agent/connect" || options.method !== "POST") {
+            headers["Authorization"] = `Bearer ${this.token}`;
+        }
+        const response = await fetch(url, { ...options, headers });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({ error: response.statusText }));
+            throw new Error(errorData.error || `HTTP ${response.status}`);
+        }
+        return response.json();
+    }
+    async connect() {
+        const data = await this.fetch("/api/agent/connect", {
+            method: "POST",
+            body: JSON.stringify({ token: this.token }),
+        });
+        this.agent = data.agent;
+        this.org = data.org;
+        this.channels = data.channels;
+        return data;
+    }
+    async disconnect() {
+        await this.fetch("/api/agent/connect", { method: "DELETE" });
+        this.agent = null;
+        this.org = null;
+        this.channels = [];
+    }
+    async updateStatus(status, activity) {
+        await this.fetch("/api/agent/connect", {
+            method: "PUT",
+            body: JSON.stringify({ status, activity }),
+        });
+    }
+    async pollMessages(channelId) {
+        const params = new URLSearchParams();
+        if (channelId)
+            params.set("channelId", channelId);
+        if (this.lastMessageTime)
+            params.set("after", this.lastMessageTime);
+        const query = params.toString();
+        const data = await this.fetch(`/api/agent/messages${query ? `?${query}` : ""}`);
+        // Update last message time for next poll
+        if (data.messages.length > 0) {
+            this.lastMessageTime = data.messages[data.messages.length - 1].createdAt;
+        }
+        return data.messages;
+    }
+    async sendMessage(channelId, content) {
+        const data = await this.fetch("/api/agent/messages", {
+            method: "POST",
+            body: JSON.stringify({ channelId, content }),
+        });
+        return data.message;
+    }
+    getChannelByName(name) {
+        return this.channels.find((c) => c.name === name);
+    }
+    getChannelById(id) {
+        return this.channels.find((c) => c.id === id);
+    }
+}

package/dist/channel.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Clack Channel Plugin for OpenClaw
+ */
+export interface ResolvedClackAccount {
+    accountId: string;
+    name: string;
+    enabled: boolean;
+    configured: boolean;
+    baseUrl: string | null;
+    config: {
+        token?: string;
+        baseUrl?: string;
+        pollIntervalMs?: number;
+        allowFrom?: string[];
+    };
+}
+export declare const clackPlugin: {
+    id: string;
+    meta: {
+        id: string;
+        label: string;
+        selectionLabel: string;
+        detailLabel: string;
+        docsPath: string;
+        docsLabel: string;
+        blurb: string;
+        systemImage: string;
+        aliases: never[];
+        order: number;
+    };
+    capabilities: {
+        chatTypes: string[];
+        media: boolean;
+        reactions: boolean;
+        edit: boolean;
+        unsend: boolean;
+        reply: boolean;
+        effects: boolean;
+        groupManagement: boolean;
+    };
+    reload: {
+        configPrefixes: string[];
+    };
+    config: {
+        listAccountIds: () => string[];
+        resolveAccount: (cfg: Record<string, unknown>, accountId?: string) => ResolvedClackAccount;
+        defaultAccountId: () => string;
+        isConfigured: (account: ResolvedClackAccount) => boolean;
+        describeAccount: (account: ResolvedClackAccount) => {
+            accountId: string;
+            name: string;
+            enabled: boolean;
+            configured: boolean;
+            baseUrl: string | null;
+        };
+    };
+    outbound: {
+        deliveryMode: string;
+        textChunkLimit: number;
+        resolveTarget: ({ to }: {
+            to?: string;
+        }) => {
+            ok: boolean;
+            error: Error;
+            to?: undefined;
+        } | {
+            ok: boolean;
+            to: string;
+            error?: undefined;
+        };
+        sendText: (ctx: {
+            cfg: Record<string, unknown>;
+            to: string;
+            text: string;
+            accountId?: string;
+        }) => Promise<{
+            channel: string;
+            ok: boolean;
+            messageId: string;
+            channelId: string;
+        }>;
+    };
+    gateway: {
+        startAccount: (ctx: {
+            account: ResolvedClackAccount;
+            cfg: Record<string, unknown>;
+            abortSignal?: AbortSignal;
+            setStatus: (status: Record<string, unknown>) => void;
+            log?: {
+                info: (msg: string) => void;
+                error?: (msg: string) => void;
+                debug?: (msg: string) => void;
+            };
+        }) => Promise<void>;
+    };
+};

package/dist/channel.js

@@ -0,0 +1,166 @@
+/**
+ * Clack Channel Plugin for OpenClaw
+ */
+import { ClackApiClient } from "./api.js";
+const DEFAULT_ACCOUNT_ID = "default";
+// Channel metadata
+const meta = {
+    id: "clack",
+    label: "Clack",
+    selectionLabel: "Clack Workspace",
+    detailLabel: "Clack",
+    docsPath: "/channels/clack",
+    docsLabel: "clack",
+    blurb: "Collaborate with humans and other agents in Clack workspaces.",
+    systemImage: "person.3.fill",
+    aliases: [],
+    order: 50,
+};
+// Resolve account from config
+function resolveClackAccount(params) {
+    const { cfg, accountId = DEFAULT_ACCOUNT_ID } = params;
+    const channels = cfg.channels;
+    const channelConfig = channels?.clack;
+    const token = channelConfig?.token;
+    const baseUrl = channelConfig?.baseUrl;
+    const configured = Boolean(token && baseUrl);
+    return {
+        accountId,
+        name: "Clack",
+        enabled: Boolean(channelConfig && channelConfig.enabled !== false),
+        configured,
+        baseUrl: baseUrl || null,
+        config: {
+            token,
+            baseUrl,
+            pollIntervalMs: channelConfig?.pollIntervalMs ?? 5000,
+        },
+    };
+}
+// Store active clients per account
+const activeClients = new Map();
+export const clackPlugin = {
+    id: "clack",
+    meta,
+    capabilities: {
+        chatTypes: ["group"],
+        media: false,
+        reactions: false,
+        edit: false,
+        unsend: false,
+        reply: false,
+        effects: false,
+        groupManagement: false,
+    },
+    reload: { configPrefixes: ["channels.clack"] },
+    config: {
+        listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+        resolveAccount: (cfg, accountId) => resolveClackAccount({ cfg, accountId }),
+        defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            baseUrl: account.baseUrl,
+        }),
+    },
+    outbound: {
+        deliveryMode: "direct",
+        textChunkLimit: 4000,
+        resolveTarget: ({ to }) => {
+            const trimmed = to?.trim();
+            if (!trimmed) {
+                return { ok: false, error: new Error("Clack requires --to <channel_id|channel_name>") };
+            }
+            return { ok: true, to: trimmed };
+        },
+        sendText: async (ctx) => {
+            const { cfg, to, text, accountId } = ctx;
+            const account = resolveClackAccount({ cfg, accountId });
+            if (!account.configured || !account.config.token || !account.config.baseUrl) {
+                throw new Error("Clack not configured - set channels.clack.token and channels.clack.baseUrl");
+            }
+            let client = activeClients.get(account.accountId);
+            if (!client) {
+                client = new ClackApiClient({
+                    token: account.config.token,
+                    baseUrl: account.config.baseUrl,
+                });
+                await client.connect();
+                activeClients.set(account.accountId, client);
+            }
+            // Resolve channel (by name or ID)
+            let channelId = to;
+            const channelByName = client.getChannelByName(to);
+            if (channelByName) {
+                channelId = channelByName.id;
+            }
+            const message = await client.sendMessage(channelId, text);
+            return {
+                channel: "clack",
+                ok: true,
+                messageId: message.id,
+                channelId: message.channelId,
+            };
+        },
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const { account, abortSignal, setStatus, log } = ctx;
+            if (!account.configured || !account.config.token || !account.config.baseUrl) {
+                throw new Error("Clack not configured");
+            }
+            log?.info(`[clack] Connecting to ${account.config.baseUrl}...`);
+            const client = new ClackApiClient({
+                token: account.config.token,
+                baseUrl: account.config.baseUrl,
+            });
+            const { agent, org, channels } = await client.connect();
+            activeClients.set(account.accountId, client);
+            log?.info(`[clack] Connected as ${agent.name} to ${org.name}`);
+            log?.info(`[clack] Channels: ${channels.map((c) => `#${c.name}`).join(", ")}`);
+            setStatus({
+                accountId: account.accountId,
+                running: true,
+                lastStartAt: new Date().toISOString(),
+                connected: true,
+            });
+            // Start polling for messages
+            const pollInterval = account.config.pollIntervalMs ?? 5000;
+            let polling = true;
+            const poll = async () => {
+                while (polling && !abortSignal?.aborted) {
+                    try {
+                        const messages = await client.pollMessages();
+                        for (const msg of messages) {
+                            log?.debug?.(`[clack] Received: [#${msg.channelName}] ${msg.sender?.name}: ${msg.content}`);
+                        }
+                    }
+                    catch (err) {
+                        log?.error?.(`[clack] Poll error: ${err}`);
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+                }
+            };
+            poll();
+            abortSignal?.addEventListener("abort", async () => {
+                polling = false;
+                try {
+                    await client.disconnect();
+                    activeClients.delete(account.accountId);
+                    log?.info("[clack] Disconnected");
+                }
+                catch (err) {
+                    log?.error?.(`[clack] Disconnect error: ${err}`);
+                }
+                setStatus({
+                    accountId: account.accountId,
+                    running: false,
+                    lastStopAt: new Date().toISOString(),
+                });
+            });
+        },
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @clackhq/openclaw-plugin
+ *
+ * OpenClaw channel plugin for Clack workspaces.
+ * Enables AI agents to collaborate with humans and other agents.
+ *
+ * @example
+ * ```yaml
+ * # gateway.yaml
+ * channels:
+ *   clack:
+ *     enabled: true
+ *     token: "clack_agent_xxx"
+ *     baseUrl: "https://clack-olive.vercel.app"
+ * ```
+ */
+export { ClackApiClient, type ClackConfig, type ClackMessage, type ClackChannel } from "./api.js";
+export { clackPlugin } from "./channel.js";
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: {
+        type: "object";
+        additionalProperties: boolean;
+        properties: {
+            token: {
+                type: "string";
+                description: string;
+            };
+            baseUrl: {
+                type: "string";
+                description: string;
+            };
+            pollIntervalMs: {
+                type: "number";
+                description: string;
+            };
+        };
+    };
+    register(api: {
+        runtime: unknown;
+        registerChannel: (opts: {
+            plugin: unknown;
+        }) => void;
+    }): void;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,37 @@
+/**
+ * @clackhq/openclaw-plugin
+ *
+ * OpenClaw channel plugin for Clack workspaces.
+ * Enables AI agents to collaborate with humans and other agents.
+ *
+ * @example
+ * ```yaml
+ * # gateway.yaml
+ * channels:
+ *   clack:
+ *     enabled: true
+ *     token: "clack_agent_xxx"
+ *     baseUrl: "https://clack-olive.vercel.app"
+ * ```
+ */
+export { ClackApiClient } from "./api.js";
+export { clackPlugin } from "./channel.js";
+// Default export for OpenClaw plugin registration
+import { clackPlugin } from "./channel.js";
+export default {
+    id: "clack",
+    name: "Clack",
+    description: "Collaborate with humans and AI agents in Clack workspaces",
+    configSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            token: { type: "string", description: "Agent connection token from Clack" },
+            baseUrl: { type: "string", description: "Clack server URL" },
+            pollIntervalMs: { type: "number", description: "Message poll interval (ms)" },
+        },
+    },
+    register(api) {
+        api.registerChannel({ plugin: clackPlugin });
+    },
+};

package/openclaw.plugin.json

@@ -0,0 +1,24 @@
+{
+  "id": "clack",
+  "channels": ["clack"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "token": {
+        "type": "string",
+        "description": "Agent connection token from Clack"
+      },
+      "baseUrl": {
+        "type": "string",
+        "description": "Clack server URL"
+      },
+      "pollIntervalMs": {
+        "type": "number",
+        "default": 5000,
+        "description": "Message poll interval in milliseconds"
+      }
+    },
+    "required": ["token", "baseUrl"]
+  }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@clackhq/openclaw-plugin",
+  "version": "0.1.0",
+  "description": "OpenClaw channel plugin for Clack workspaces - collaborate with humans and AI agents",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "openclaw",
+    "clack",
+    "ai-agents",
+    "collaboration",
+    "slack-alternative"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Clack-HQ/clack.git",
+    "directory": "packages/openclaw-plugin"
+  },
+  "homepage": "https://clackhq.com",
+  "bugs": {
+    "url": "https://github.com/Clack-HQ/clack/issues"
+  },
+  "license": "MIT",
+  "author": "Clack <hello@clackhq.com>",
+  "peerDependencies": {
+    "openclaw": ">=2025.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/src/api.ts

@@ -0,0 +1,155 @@
+/**
+ * Clack API client for OpenClaw plugin
+ */
+
+export interface ClackConfig {
+  token: string;
+  baseUrl: string;
+  pollIntervalMs?: number;
+}
+
+export interface ClackChannel {
+  id: string;
+  name: string;
+  description: string | null;
+  type: "STANDARD" | "AGENT_COLLAB" | "DM";
+  involvement: "ACTIVE" | "MENTIONED" | "WATCHING" | "OFF";
+}
+
+export interface ClackMessage {
+  id: string;
+  content: string;
+  channelId: string;
+  channelName: string;
+  sender: {
+    type: "user" | "agent";
+    id: string;
+    name: string | null;
+    avatarUrl: string | null;
+  } | null;
+  createdAt: string;
+}
+
+export interface ClackAgent {
+  id: string;
+  name: string;
+  avatarUrl: string | null;
+}
+
+export interface ClackOrg {
+  id: string;
+  name: string;
+  slug: string;
+}
+
+export interface ClackConnectionInfo {
+  agent: ClackAgent;
+  org: ClackOrg;
+  channels: ClackChannel[];
+}
+
+function isValidTokenFormat(token: string): boolean {
+  return /^clack_agent_[a-f0-9]{32}$/.test(token);
+}
+
+export class ClackApiClient {
+  private token: string;
+  private baseUrl: string;
+  private lastMessageTime: string | null = null;
+
+  public agent: ClackAgent | null = null;
+  public org: ClackOrg | null = null;
+  public channels: ClackChannel[] = [];
+
+  constructor(config: ClackConfig) {
+    this.token = config.token;
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+
+    if (!isValidTokenFormat(this.token)) {
+      throw new Error(`Invalid Clack token format. Expected: clack_agent_<32 hex chars>`);
+    }
+  }
+
+  private async fetch<T>(path: string, options: RequestInit = {}): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      ...(options.headers as Record<string, string>),
+    };
+
+    // Add auth header for authenticated requests (not connect POST)
+    if (path !== "/api/agent/connect" || options.method !== "POST") {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+
+    const response = await fetch(url, { ...options, headers });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: response.statusText })) as { error?: string };
+      throw new Error(errorData.error || `HTTP ${response.status}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  async connect(): Promise<ClackConnectionInfo> {
+    const data = await this.fetch<ClackConnectionInfo>("/api/agent/connect", {
+      method: "POST",
+      body: JSON.stringify({ token: this.token }),
+    });
+
+    this.agent = data.agent;
+    this.org = data.org;
+    this.channels = data.channels;
+
+    return data;
+  }
+
+  async disconnect(): Promise<void> {
+    await this.fetch<{ success: boolean }>("/api/agent/connect", { method: "DELETE" });
+    this.agent = null;
+    this.org = null;
+    this.channels = [];
+  }
+
+  async updateStatus(status: "ONLINE" | "OFFLINE" | "BUSY", activity?: string): Promise<void> {
+    await this.fetch<{ success: boolean }>("/api/agent/connect", {
+      method: "PUT",
+      body: JSON.stringify({ status, activity }),
+    });
+  }
+
+  async pollMessages(channelId?: string): Promise<ClackMessage[]> {
+    const params = new URLSearchParams();
+    if (channelId) params.set("channelId", channelId);
+    if (this.lastMessageTime) params.set("after", this.lastMessageTime);
+
+    const query = params.toString();
+    const data = await this.fetch<{ messages: ClackMessage[] }>(
+      `/api/agent/messages${query ? `?${query}` : ""}`
+    );
+
+    // Update last message time for next poll
+    if (data.messages.length > 0) {
+      this.lastMessageTime = data.messages[data.messages.length - 1].createdAt;
+    }
+
+    return data.messages;
+  }
+
+  async sendMessage(channelId: string, content: string): Promise<ClackMessage> {
+    const data = await this.fetch<{ message: ClackMessage }>("/api/agent/messages", {
+      method: "POST",
+      body: JSON.stringify({ channelId, content }),
+    });
+    return data.message;
+  }
+
+  getChannelByName(name: string): ClackChannel | undefined {
+    return this.channels.find((c) => c.name === name);
+  }
+
+  getChannelById(id: string): ClackChannel | undefined {
+    return this.channels.find((c) => c.id === id);
+  }
+}

package/src/channel.ts

@@ -0,0 +1,217 @@
+/**
+ * Clack Channel Plugin for OpenClaw
+ */
+
+import { ClackApiClient, type ClackConfig } from "./api.js";
+
+const DEFAULT_ACCOUNT_ID = "default";
+
+// Resolved account configuration
+export interface ResolvedClackAccount {
+  accountId: string;
+  name: string;
+  enabled: boolean;
+  configured: boolean;
+  baseUrl: string | null;
+  config: {
+    token?: string;
+    baseUrl?: string;
+    pollIntervalMs?: number;
+    allowFrom?: string[];
+  };
+}
+
+// Channel metadata
+const meta = {
+  id: "clack",
+  label: "Clack",
+  selectionLabel: "Clack Workspace",
+  detailLabel: "Clack",
+  docsPath: "/channels/clack",
+  docsLabel: "clack",
+  blurb: "Collaborate with humans and other agents in Clack workspaces.",
+  systemImage: "person.3.fill",
+  aliases: [],
+  order: 50,
+};
+
+// Resolve account from config
+function resolveClackAccount(params: {
+  cfg: Record<string, unknown>;
+  accountId?: string;
+}): ResolvedClackAccount {
+  const { cfg, accountId = DEFAULT_ACCOUNT_ID } = params;
+  const channels = cfg.channels as Record<string, unknown> | undefined;
+  const channelConfig = channels?.clack as ClackConfig | undefined;
+
+  const token = channelConfig?.token;
+  const baseUrl = channelConfig?.baseUrl;
+  const configured = Boolean(token && baseUrl);
+
+  return {
+    accountId,
+    name: "Clack",
+    enabled: Boolean(channelConfig && (channelConfig as { enabled?: boolean }).enabled !== false),
+    configured,
+    baseUrl: baseUrl || null,
+    config: {
+      token,
+      baseUrl,
+      pollIntervalMs: channelConfig?.pollIntervalMs ?? 5000,
+    },
+  };
+}
+
+// Store active clients per account
+const activeClients = new Map<string, ClackApiClient>();
+
+export const clackPlugin = {
+  id: "clack",
+  meta,
+  capabilities: {
+    chatTypes: ["group"],
+    media: false,
+    reactions: false,
+    edit: false,
+    unsend: false,
+    reply: false,
+    effects: false,
+    groupManagement: false,
+  },
+  reload: { configPrefixes: ["channels.clack"] },
+  config: {
+    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+    resolveAccount: (cfg: Record<string, unknown>, accountId?: string) => 
+      resolveClackAccount({ cfg, accountId }),
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+    isConfigured: (account: ResolvedClackAccount) => account.configured,
+    describeAccount: (account: ResolvedClackAccount) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+      baseUrl: account.baseUrl,
+    }),
+  },
+  outbound: {
+    deliveryMode: "direct",
+    textChunkLimit: 4000,
+    resolveTarget: ({ to }: { to?: string }) => {
+      const trimmed = to?.trim();
+      if (!trimmed) {
+        return { ok: false, error: new Error("Clack requires --to <channel_id|channel_name>") };
+      }
+      return { ok: true, to: trimmed };
+    },
+    sendText: async (ctx: { 
+      cfg: Record<string, unknown>; 
+      to: string; 
+      text: string; 
+      accountId?: string 
+    }) => {
+      const { cfg, to, text, accountId } = ctx;
+      const account = resolveClackAccount({ cfg, accountId });
+      
+      if (!account.configured || !account.config.token || !account.config.baseUrl) {
+        throw new Error("Clack not configured - set channels.clack.token and channels.clack.baseUrl");
+      }
+
+      let client = activeClients.get(account.accountId);
+      if (!client) {
+        client = new ClackApiClient({
+          token: account.config.token,
+          baseUrl: account.config.baseUrl,
+        });
+        await client.connect();
+        activeClients.set(account.accountId, client);
+      }
+
+      // Resolve channel (by name or ID)
+      let channelId = to;
+      const channelByName = client.getChannelByName(to);
+      if (channelByName) {
+        channelId = channelByName.id;
+      }
+
+      const message = await client.sendMessage(channelId, text);
+
+      return {
+        channel: "clack",
+        ok: true,
+        messageId: message.id,
+        channelId: message.channelId,
+      };
+    },
+  },
+  gateway: {
+    startAccount: async (ctx: {
+      account: ResolvedClackAccount;
+      cfg: Record<string, unknown>;
+      abortSignal?: AbortSignal;
+      setStatus: (status: Record<string, unknown>) => void;
+      log?: { info: (msg: string) => void; error?: (msg: string) => void; debug?: (msg: string) => void };
+    }) => {
+      const { account, abortSignal, setStatus, log } = ctx;
+      
+      if (!account.configured || !account.config.token || !account.config.baseUrl) {
+        throw new Error("Clack not configured");
+      }
+
+      log?.info(`[clack] Connecting to ${account.config.baseUrl}...`);
+
+      const client = new ClackApiClient({
+        token: account.config.token,
+        baseUrl: account.config.baseUrl,
+      });
+
+      const { agent, org, channels } = await client.connect();
+      activeClients.set(account.accountId, client);
+
+      log?.info(`[clack] Connected as ${agent.name} to ${org.name}`);
+      log?.info(`[clack] Channels: ${channels.map((c) => `#${c.name}`).join(", ")}`);
+
+      setStatus({
+        accountId: account.accountId,
+        running: true,
+        lastStartAt: new Date().toISOString(),
+        connected: true,
+      });
+
+      // Start polling for messages
+      const pollInterval = account.config.pollIntervalMs ?? 5000;
+      let polling = true;
+
+      const poll = async () => {
+        while (polling && !abortSignal?.aborted) {
+          try {
+            const messages = await client.pollMessages();
+            for (const msg of messages) {
+              log?.debug?.(`[clack] Received: [#${msg.channelName}] ${msg.sender?.name}: ${msg.content}`);
+            }
+          } catch (err) {
+            log?.error?.(`[clack] Poll error: ${err}`);
+          }
+          await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        }
+      };
+
+      poll();
+
+      abortSignal?.addEventListener("abort", async () => {
+        polling = false;
+        try {
+          await client.disconnect();
+          activeClients.delete(account.accountId);
+          log?.info("[clack] Disconnected");
+        } catch (err) {
+          log?.error?.(`[clack] Disconnect error: ${err}`);
+        }
+        setStatus({
+          accountId: account.accountId,
+          running: false,
+          lastStopAt: new Date().toISOString(),
+        });
+      });
+    },
+  },
+};

package/src/index.ts

@@ -0,0 +1,39 @@
+/**
+ * @clackhq/openclaw-plugin
+ * 
+ * OpenClaw channel plugin for Clack workspaces.
+ * Enables AI agents to collaborate with humans and other agents.
+ * 
+ * @example
+ * ```yaml
+ * # gateway.yaml
+ * channels:
+ *   clack:
+ *     enabled: true
+ *     token: "clack_agent_xxx"
+ *     baseUrl: "https://clack-olive.vercel.app"
+ * ```
+ */
+
+export { ClackApiClient, type ClackConfig, type ClackMessage, type ClackChannel } from "./api.js";
+export { clackPlugin } from "./channel.js";
+
+// Default export for OpenClaw plugin registration
+import { clackPlugin } from "./channel.js";
+export default {
+  id: "clack",
+  name: "Clack",
+  description: "Collaborate with humans and AI agents in Clack workspaces",
+  configSchema: {
+    type: "object" as const,
+    additionalProperties: false,
+    properties: {
+      token: { type: "string" as const, description: "Agent connection token from Clack" },
+      baseUrl: { type: "string" as const, description: "Clack server URL" },
+      pollIntervalMs: { type: "number" as const, description: "Message poll interval (ms)" },
+    },
+  },
+  register(api: { runtime: unknown; registerChannel: (opts: { plugin: unknown }) => void }) {
+    api.registerChannel({ plugin: clackPlugin });
+  },
+};

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "esModuleInterop": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}