@coolclaw/coolclaw 0.2.6 → 0.2.7

package/dist/chunk-BPNTPLYX.js

@@ -1,1173 +0,0 @@
-// src/ack-store.ts
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-var InMemoryAckStore = class {
-  cursors = /* @__PURE__ */ new Map();
-  async getLastAckedSeq(accountKey) {
-    return this.cursors.get(accountKey) ?? 0;
-  }
-  async record(accountKey, seq) {
-    if (!Number.isInteger(seq) || seq < 1) {
-      throw new Error(`Invalid ACK seq: ${seq}`);
-    }
-    const current = this.cursors.get(accountKey) ?? 0;
-    if (seq <= current) {
-      return current;
-    }
-    this.cursors.set(accountKey, seq);
-    return seq;
-  }
-};
-var FileAckStore = class {
-  cursors = /* @__PURE__ */ new Map();
-  dir;
-  constructor(dir) {
-    this.dir = dir ?? join(homedir(), ".openclaw", "extensions", "coolclaw", ".ack-store");
-    if (!existsSync(this.dir)) {
-      mkdirSync(this.dir, { recursive: true });
-    }
-  }
-  async getLastAckedSeq(accountKey) {
-    return this.cursors.get(accountKey) ?? this.load(accountKey);
-  }
-  async record(accountKey, seq) {
-    if (!Number.isInteger(seq) || seq < 1) {
-      throw new Error(`Invalid ACK seq: ${seq}`);
-    }
-    const current = this.cursors.get(accountKey) ?? this.load(accountKey);
-    if (seq <= current) {
-      return current;
-    }
-    this.cursors.set(accountKey, seq);
-    this.persist(accountKey, seq);
-    return seq;
-  }
-  load(accountKey) {
-    const filePath = this.filePath(accountKey);
-    if (!existsSync(filePath)) {
-      return 0;
-    }
-    try {
-      const text = readFileSync(filePath, "utf-8").trim();
-      const value = parseInt(text, 10);
-      return Number.isFinite(value) && value >= 0 ? value : 0;
-    } catch {
-      return 0;
-    }
-  }
-  persist(accountKey, lastAckedSeq) {
-    try {
-      writeFileSync(this.filePath(accountKey), String(lastAckedSeq), "utf-8");
-    } catch {
-    }
-  }
-  filePath(accountKey) {
-    const safeName = accountKey.replace(/[^a-zA-Z0-9_-]/g, "_");
-    return join(this.dir, `${safeName}.ack`);
-  }
-};
-
-// src/binding.ts
-import { mkdir, readFile, rename, writeFile, chmod } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import path from "path";
-import { fileURLToPath } from "url";
-var RIDDLE_BINDING_VERSION = 1;
-function defaultBindingFile(home = homedir2()) {
-  return path.join(home, ".config", "coolclaw", "agent_binding.json");
-}
-function defaultOpenClawConfigFile(home = homedir2()) {
-  return path.join(home, ".openclaw", "openclaw.json");
-}
-function defaultTokenFile(bindingFile, agentId) {
-  return path.join(path.dirname(bindingFile), `agent_token_${agentId}.txt`);
-}
-async function loadBinding(bindingFile) {
-  try {
-    const raw = JSON.parse(await readFile(bindingFile, "utf8"));
-    return {
-      agentId: String(raw.agentId ?? ""),
-      tokenRef: typeof raw.tokenRef === "string" ? raw.tokenRef : null,
-      runtimeType: String(raw.runtimeType ?? "unknown"),
-      lastAckedSeq: Number(raw.lastAckedSeq ?? 0),
-      bindingVersion: Number(raw.bindingVersion ?? RIDDLE_BINDING_VERSION),
-      updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : void 0
-    };
-  } catch {
-    return {
-      agentId: "",
-      tokenRef: null,
-      runtimeType: "unknown",
-      lastAckedSeq: 0,
-      bindingVersion: RIDDLE_BINDING_VERSION
-    };
-  }
-}
-function touchBinding(binding) {
-  return {
-    ...binding,
-    bindingVersion: RIDDLE_BINDING_VERSION,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z")
-  };
-}
-async function saveBinding(bindingFile, binding) {
-  await mkdir(path.dirname(bindingFile), { recursive: true });
-  const tmpFile = `${bindingFile}.${process.pid}.tmp`;
-  await writeFile(tmpFile, `${JSON.stringify(touchBinding(binding), null, 2)}
-`, { mode: 384 });
-  await chmod(tmpFile, 384);
-  await rename(tmpFile, bindingFile);
-}
-async function saveAgentToken(tokenFile, token) {
-  await mkdir(path.dirname(tokenFile), { recursive: true });
-  await writeFile(tokenFile, token, { mode: 384 });
-  await chmod(tokenFile, 384);
-}
-async function readTokenRef(tokenRef) {
-  if (!tokenRef) return void 0;
-  if (tokenRef.startsWith("env:")) {
-    return process.env[tokenRef.slice("env:".length)] || void 0;
-  }
-  if (tokenRef.startsWith("file://")) {
-    const tokenPath = fileURLToPath(tokenRef);
-    return (await readFile(tokenPath, "utf8")).trim() || void 0;
-  }
-  return void 0;
-}
-
-// src/config.ts
-function normalizeGatewayUrl(value) {
-  return value.trim().replace(/\/+$/, "");
-}
-function buildWsUrl(gatewayUrl, lastAckedSeq) {
-  const baseUrl = normalizeGatewayUrl(gatewayUrl).replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
-  return `${baseUrl}/ws/channel?lastAckedSeq=${lastAckedSeq}`;
-}
-function resolveAccountConfig(source, env = process.env) {
-  const account = readDefaultAccount(source);
-  if (account) {
-    return finalizeAccount(account, "config");
-  }
-  const envAccount = readEnvAccount(env);
-  if (envAccount) {
-    return finalizeAccount(envAccount, "env");
-  }
-  return {
-    configured: false,
-    source: "none",
-    reasons: ["Missing CoolClaw account config"]
-  };
-}
-function inspectAccount(account) {
-  const config = account.config;
-  return JSON.stringify({
-    configured: account.configured,
-    source: account.source,
-    gatewayUrl: config?.gatewayUrl,
-    agentId: config?.agentId,
-    tokenConfigured: Boolean(config?.tokenSecretRef),
-    tokenSecretRef: maskSecretRef(config?.tokenSecretRef),
-    allowFromCount: config?.allowFrom?.length ?? 0,
-    dmPolicy: config?.dmPolicy,
-    reasons: account.reasons
-  });
-}
-async function resolveAccountToken(account) {
-  if (account.tokenSecret) return account.tokenSecret;
-  return readTokenRef(account.tokenSecretRef);
-}
-function readDefaultAccount(source) {
-  if (!isRecord(source)) return void 0;
-  const channels = source.channels;
-  if (!isRecord(channels)) return void 0;
-  const coolclaw = channels.coolclaw;
-  if (!isRecord(coolclaw)) return void 0;
-  const accounts = coolclaw.accounts;
-  if (!isRecord(accounts)) return void 0;
-  const defaultAccount = accounts.default;
-  return isRecord(defaultAccount) ? coerceRawAccount(defaultAccount) : void 0;
-}
-function readEnvAccount(env) {
-  if (!env.COOLCLAW_GATEWAY_URL && !env.COOLCLAW_AGENT_ID && !env.COOLCLAW_AGENT_TOKEN && !env.COOLCLAW_AGENT_TOKEN_SECRET_REF) {
-    return void 0;
-  }
-  return {
-    gatewayUrl: env.COOLCLAW_GATEWAY_URL,
-    agentId: env.COOLCLAW_AGENT_ID,
-    tokenSecretRef: env.COOLCLAW_AGENT_TOKEN_SECRET_REF ?? (env.COOLCLAW_AGENT_TOKEN ? "env:COOLCLAW_AGENT_TOKEN" : void 0),
-    allowFrom: splitCsv(env.COOLCLAW_ALLOW_FROM),
-    dmPolicy: coerceDmPolicy(env.COOLCLAW_DM_POLICY)
-  };
-}
-function finalizeAccount(account, source) {
-  const gatewayUrl = typeof account.gatewayUrl === "string" ? normalizeGatewayUrl(account.gatewayUrl) : "";
-  const agentId = typeof account.agentId === "string" ? account.agentId.trim() : "";
-  const tokenSecretRef = typeof account.tokenSecretRef === "string" ? account.tokenSecretRef.trim() : account.tokenSecret?.trim();
-  const allowFrom = normalizeStringArray(account.allowFrom);
-  const dmPolicy = coerceDmPolicy(account.dmPolicy) ?? "open";
-  const reasons = [];
-  if (!gatewayUrl) reasons.push("Missing gateway URL");
-  if (!agentId) reasons.push("Missing Agent ID");
-  if (!tokenSecretRef) reasons.push("Missing token secret reference");
-  const config = {
-    gatewayUrl,
-    agentId,
-    tokenSecretRef,
-    allowFrom,
-    dmPolicy
-  };
-  if (reasons.length > 0) {
-    return {
-      configured: false,
-      source,
-      config,
-      reasons
-    };
-  }
-  return {
-    configured: true,
-    source,
-    config,
-    reasons: []
-  };
-}
-function coerceRawAccount(value) {
-  return {
-    gatewayUrl: typeof value.gatewayUrl === "string" ? value.gatewayUrl : void 0,
-    agentId: typeof value.agentId === "string" ? value.agentId : void 0,
-    tokenSecretRef: typeof value.tokenSecretRef === "string" ? value.tokenSecretRef : void 0,
-    tokenSecret: typeof value.tokenSecret === "string" ? value.tokenSecret : void 0,
-    allowFrom: normalizeStringArray(value.allowFrom),
-    dmPolicy: coerceDmPolicy(value.dmPolicy)
-  };
-}
-function normalizeStringArray(value) {
-  if (!Array.isArray(value)) return void 0;
-  const items = value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
-  return items.length > 0 ? items : void 0;
-}
-function splitCsv(value) {
-  if (!value) return void 0;
-  const items = value.split(",").map((item) => item.trim()).filter(Boolean);
-  return items.length > 0 ? items : void 0;
-}
-function coerceDmPolicy(value) {
-  return value === "pairing" || value === "allowlist" || value === "open" ? value : void 0;
-}
-function maskSecretRef(value) {
-  if (!value) return void 0;
-  if (value.startsWith("env:")) return value;
-  const tail = value.slice(-4);
-  return tail ? `***${tail}` : "***";
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/frame-codec.ts
-import { randomUUID } from "crypto";
-var CoolclawFrameDecodeError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CoolclawFrameDecodeError";
-  }
-};
-function createFrame(type, payload) {
-  return {
-    v: 1,
-    type,
-    id: `cli_${randomUUID()}`,
-    ts: Date.now(),
-    payload
-  };
-}
-function encodeFrame(frame) {
-  return JSON.stringify(frame);
-}
-function decodeFrame(raw) {
-  let value;
-  try {
-    value = JSON.parse(raw);
-  } catch (error) {
-    throw new CoolclawFrameDecodeError(`Invalid CoolClaw frame JSON: ${error.message}`);
-  }
-  if (!isRecord2(value)) {
-    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: expected object");
-  }
-  if (!("v" in value)) {
-    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: missing v");
-  }
-  if (value.v !== 1) {
-    throw new CoolclawFrameDecodeError("Unsupported CoolClaw frame version");
-  }
-  if (typeof value.type !== "string" || value.type.length === 0) {
-    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: missing type");
-  }
-  if (typeof value.id !== "string" || value.id.length === 0) {
-    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: missing id");
-  }
-  if (typeof value.ts !== "number" || !Number.isFinite(value.ts)) {
-    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: missing ts");
-  }
-  if ("ack" in value && value.ack !== void 0 && typeof value.ack !== "string") {
-    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: ack must be a string");
-  }
-  const frame = {
-    v: 1,
-    type: value.type,
-    id: value.id,
-    ts: value.ts
-  };
-  if (typeof value.ack === "string") {
-    frame.ack = value.ack;
-  }
-  if ("payload" in value) {
-    frame.payload = value.payload;
-  }
-  return frame;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/security.ts
-function applyInboundSecurityPolicy(envelope, config) {
-  if (!isPrivateConversation(envelope)) {
-    return {
-      accepted: true,
-      envelope: {
-        ...envelope,
-        shouldReply: envelope.group ? envelope.shouldReply === true : false
-      }
-    };
-  }
-  const senderKey = envelope.sender ? toIdentityKey(envelope.sender.userType, envelope.sender.userId) : void 0;
-  const allowFrom = new Set((config.allowFrom ?? []).map(normalizeIdentityKey));
-  if (senderKey && allowFrom.has(senderKey)) {
-    return { accepted: true, envelope };
-  }
-  if ((config.dmPolicy ?? "allowlist") === "open") {
-    return { accepted: true, envelope };
-  }
-  if ((config.dmPolicy ?? "allowlist") === "pairing" && envelope.sender) {
-    return {
-      accepted: true,
-      envelope: {
-        ...envelope,
-        conversationId: `pairing:${senderKey}`,
-        shouldReply: false,
-        metadata: {
-          ...envelope.metadata,
-          pairingRequired: true,
-          originalConversationId: envelope.conversationId
-        }
-      }
-    };
-  }
-  return {
-    accepted: false,
-    reason: "DM sender is not allowlisted",
-    envelope: {
-      ...envelope,
-      shouldReply: false,
-      metadata: {
-        ...envelope.metadata,
-        blockedByPolicy: true
-      }
-    }
-  };
-}
-function isPrivateConversation(envelope) {
-  return envelope.conversationId.startsWith("private:");
-}
-function toIdentityKey(userType, userId) {
-  return `${userType.toLowerCase()}:${userId}`;
-}
-function normalizeIdentityKey(value) {
-  return value.trim().toLowerCase();
-}
-
-// src/inbound.ts
-function mapInboundFrame(frame) {
-  if (frame.type === "PRIVATE_MESSAGE") {
-    const payload = assertPrivatePayload(frame.payload);
-    return {
-      id: payload.messageId,
-      channel: "coolclaw",
-      conversationId: `private:${payload.sender.userType}:${payload.sender.userId}`,
-      text: payload.content,
-      messageType: payload.messageType,
-      seq: payload.seq,
-      shouldReply: payload.mentioned,
-      sender: payload.sender,
-      recipient: payload.recipient,
-      metadata: {
-        riddleConversationId: payload.conversationId,
-        sentAt: payload.sentAt,
-        sourceFrameId: frame.id
-      }
-    };
-  }
-  if (frame.type === "GROUP_MESSAGE") {
-    const payload = assertGroupPayload(frame.payload);
-    return {
-      id: payload.messageId,
-      channel: "coolclaw",
-      conversationId: `group:${payload.groupId}`,
-      text: payload.content,
-      messageType: payload.messageType,
-      seq: payload.seq,
-      shouldReply: payload.mentioned,
-      sender: payload.sender,
-      group: {
-        groupId: payload.groupId,
-        groupName: payload.groupName
-      },
-      metadata: {
-        riddleConversationId: payload.conversationId,
-        sentAt: payload.sentAt,
-        sourceFrameId: frame.id,
-        agentHint: payload.agentHint
-      }
-    };
-  }
-  if (frame.type === "SYSTEM_NOTIFICATION" || frame.type === "GAME_EVENT" || frame.type === "CONTENT_TASK") {
-    return mapNotificationFrame(frame);
-  }
-  throw new Error(`Unsupported inbound CoolClaw frame type: ${frame.type}`);
-}
-async function handleInboundFrame(input) {
-  const mappedEnvelope = mapInboundFrame(input.frame);
-  const decision = input.accountConfig ? applyInboundSecurityPolicy(mappedEnvelope, input.accountConfig) : { accepted: true, envelope: mappedEnvelope };
-  const envelope = decision.envelope;
-  await ackProcessedSeq(input, envelope);
-  if (!decision.accepted) {
-    return;
-  }
-  await input.dispatch(envelope);
-}
-function mapNotificationFrame(frame) {
-  const payload = isRecord3(frame.payload) ? frame.payload : {};
-  const seq = typeof payload.seq === "number" ? payload.seq : void 0;
-  return {
-    id: frame.id,
-    channel: "coolclaw",
-    conversationId: frame.type === "SYSTEM_NOTIFICATION" ? "notification:system" : `notification:${frame.type.toLowerCase()}`,
-    text: JSON.stringify(frame.payload ?? {}),
-    messageType: frame.type,
-    seq,
-    shouldReply: false,
-    metadata: {
-      sourceFrameId: frame.id,
-      payload: frame.payload
-    }
-  };
-}
-async function ackProcessedSeq(input, envelope) {
-  if (typeof envelope.seq === "number") {
-    const lastAckedSeq = await input.ackStore.record(input.accountKey, envelope.seq);
-    await input.sendAck(createFrame("ACK", { lastAckedSeq }));
-  }
-}
-function assertPrivatePayload(value) {
-  if (!isRecord3(value) || !isUserRef(value.sender) || !isUserRef(value.recipient)) {
-    throw new Error("Invalid PRIVATE_MESSAGE payload");
-  }
-  return {
-    seq: readNumber(value, "seq"),
-    messageId: readString(value, "messageId"),
-    conversationId: readString(value, "conversationId"),
-    sender: value.sender,
-    recipient: value.recipient,
-    messageType: readString(value, "messageType"),
-    content: readString(value, "content"),
-    mentioned: readBoolean(value, "mentioned"),
-    sentAt: readString(value, "sentAt")
-  };
-}
-function assertGroupPayload(value) {
-  if (!isRecord3(value) || !isUserRef(value.sender)) {
-    throw new Error("Invalid GROUP_MESSAGE payload");
-  }
-  return {
-    seq: readNumber(value, "seq"),
-    messageId: readString(value, "messageId"),
-    groupId: readString(value, "groupId"),
-    groupName: readString(value, "groupName"),
-    conversationId: readString(value, "conversationId"),
-    sender: value.sender,
-    messageType: readString(value, "messageType"),
-    content: readString(value, "content"),
-    mentioned: readBoolean(value, "mentioned"),
-    sentAt: readString(value, "sentAt"),
-    agentHint: readOptionalString(value, "agentHint")
-  };
-}
-function readString(source, key) {
-  const value = source[key];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`Invalid inbound payload: missing ${key}`);
-  }
-  return value;
-}
-function readNumber(source, key) {
-  const value = source[key];
-  if (typeof value !== "number" || !Number.isInteger(value)) {
-    throw new Error(`Invalid inbound payload: missing ${key}`);
-  }
-  return value;
-}
-function readBoolean(source, key) {
-  const value = source[key];
-  if (typeof value !== "boolean") {
-    throw new Error(`Invalid inbound payload: missing ${key}`);
-  }
-  return value;
-}
-function readOptionalString(source, key) {
-  const value = source[key];
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  if (typeof value !== "string") {
-    throw new Error(`Invalid inbound payload: ${key} must be a string`);
-  }
-  return value;
-}
-function isUserRef(value) {
-  return isRecord3(value) && typeof value.userId === "string" && (value.userType === "HUMAN" || value.userType === "AGENT") && (value.displayName === void 0 || typeof value.displayName === "string");
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/targets.ts
-var TargetParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TargetParseError";
-  }
-};
-function parseCoolclawTarget(raw) {
-  const normalized = normalizeCoolclawTarget(raw);
-  const parts = normalized.split(":");
-  if (parts.length !== 3) {
-    throw new TargetParseError(`Invalid CoolClaw target: ${raw}`);
-  }
-  const [channel, type, id] = parts;
-  if (channel !== "coolclaw" || id.length === 0) {
-    throw new TargetParseError(`Invalid CoolClaw target: ${raw}`);
-  }
-  if (type === "human") {
-    return { kind: "private", userType: "HUMAN", userId: id };
-  }
-  if (type === "agent") {
-    return { kind: "private", userType: "AGENT", userId: id };
-  }
-  if (type === "group") {
-    return { kind: "group", groupId: id };
-  }
-  throw new TargetParseError(`Invalid CoolClaw target type: ${type}`);
-}
-function normalizeCoolclawTarget(raw) {
-  const trimmed = raw.trim();
-  const parts = trimmed.split(":");
-  if (parts.length !== 3) {
-    return trimmed;
-  }
-  const [channel, type, id] = parts;
-  return `${channel.toLowerCase()}:${type.toLowerCase()}:${id.trim()}`;
-}
-function inferCoolclawTargetChatType(raw) {
-  try {
-    const target = parseCoolclawTarget(raw);
-    return target.kind === "private" ? "direct" : "group";
-  } catch {
-    return void 0;
-  }
-}
-function isCoolclawTargetId(raw, normalized = normalizeCoolclawTarget(raw)) {
-  try {
-    parseCoolclawTarget(normalized);
-    return normalized.startsWith("coolclaw:");
-  } catch {
-    return false;
-  }
-}
-async function resolveCoolclawMessagingTarget(raw, preferredKind) {
-  const normalized = normalizeCoolclawTarget(raw);
-  const target = parseCoolclawTarget(normalized);
-  const kind = target.kind === "private" ? "user" : "group";
-  if (preferredKind && preferredKind !== kind) {
-    return null;
-  }
-  const [, type, id] = normalized.split(":");
-  return {
-    to: normalized,
-    kind,
-    display: `${type}:${id}`,
-    source: "normalized"
-  };
-}
-
-// src/outbound.ts
-async function sendText(input) {
-  const target = parseCoolclawTarget(input.target);
-  const frame = target.kind === "private" ? createFrame("SEND_PRIVATE", {
-    target: {
-      userId: target.userId,
-      userType: target.userType
-    },
-    messageType: "TEXT",
-    content: input.text
-  }) : createFrame("SEND_GROUP", {
-    groupId: target.groupId,
-    messageType: "TEXT",
-    content: input.text
-  });
-  const response = await input.client.request(frame);
-  if (response.ok === false) {
-    throw new Error(response.error?.message ?? "CoolClaw message send failed");
-  }
-  if (!response.messageId) {
-    throw new Error("CoolClaw message send response missing messageId");
-  }
-  return response.messageId;
-}
-
-// src/status.ts
-function getCoolclawStatus(source) {
-  return createStatus(resolveAccountConfig(source ?? {}));
-}
-function createStatus(account) {
-  return {
-    configured: account.configured,
-    connected: false,
-    message: account.configured ? "CoolClaw account is configured." : account.reasons.join("; "),
-    diagnostics: inspectAccount(account)
-  };
-}
-
-// src/ws-client.ts
-import WebSocket from "ws";
-var CoolclawWsClient = class {
-  constructor(options) {
-    this.options = options;
-  }
-  socket;
-  heartbeatTimer;
-  reconnectTimer;
-  stopped = true;
-  pendingRequests = /* @__PURE__ */ new Map();
-  async start() {
-    this.stopped = false;
-    await this.connect();
-  }
-  async stop() {
-    this.stopped = true;
-    this.clearHeartbeat();
-    this.clearReconnect();
-    this.rejectPending(new Error("CoolClaw WSS client stopped"));
-    const socket = this.socket;
-    this.socket = void 0;
-    if (!socket || socket.readyState === WebSocket.CLOSED) {
-      return;
-    }
-    await new Promise((resolve) => {
-      socket.once("close", () => resolve());
-      socket.close(1e3, "client stopped");
-    });
-  }
-  async request(frame) {
-    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
-      throw new Error("CoolClaw WSS client is not connected");
-    }
-    const requestTimeoutMs = this.options.requestTimeoutMs ?? 1e4;
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingRequests.delete(frame.id);
-        reject(new Error(`CoolClaw request timed out: ${frame.type}`));
-      }, requestTimeoutMs);
-      this.pendingRequests.set(frame.id, {
-        resolve: (payload) => resolve(payload),
-        reject,
-        timeout
-      });
-      this.sendFrame(frame);
-    });
-  }
-  sendFrame(frame) {
-    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
-      throw new Error("CoolClaw WSS client is not connected");
-    }
-    this.socket.send(encodeFrame(frame));
-  }
-  async connect() {
-    const lastAckedSeq = await this.options.ackStore.getLastAckedSeq(this.options.accountKey);
-    const socket = new WebSocket(buildWsUrl(this.options.gatewayUrl, lastAckedSeq), {
-      headers: {
-        Authorization: `Bearer ${this.options.token}`,
-        "X-CoolClaw-Agent-Id": this.options.agentId,
-        "X-CoolClaw-Plugin-Version": this.options.pluginVersion
-      }
-    });
-    this.socket = socket;
-    await new Promise((resolve, reject) => {
-      let helloReceived = false;
-      const failBeforeHello = (error) => {
-        if (!helloReceived) {
-          cleanupBeforeHello();
-          reject(error);
-        }
-      };
-      const cleanupBeforeHello = () => {
-        socket.off("error", failBeforeHello);
-        socket.off("message", onMessageBeforeHello);
-        socket.off("close", onCloseBeforeHello);
-      };
-      const onMessageBeforeHello = (data) => {
-        let frame;
-        try {
-          frame = decodeFrame(data.toString());
-        } catch (error) {
-          failBeforeHello(error);
-          return;
-        }
-        this.handleFrame(frame).catch((error) => {
-          this.rejectPending(error instanceof Error ? error : new Error(String(error)));
-        });
-        if (frame.type === "HELLO") {
-          helloReceived = true;
-          cleanupBeforeHello();
-          socket.on("message", (nextData) => {
-            this.handleRawMessage(nextData).catch((error) => {
-              this.rejectPending(error instanceof Error ? error : new Error(String(error)));
-            });
-          });
-          socket.on("close", (code) => this.handleClose(code));
-          this.startHeartbeat(frame);
-          resolve();
-        }
-      };
-      const onCloseBeforeHello = (code) => {
-        const error = new Error(`CoolClaw WSS closed before HELLO: ${code}`);
-        cleanupBeforeHello();
-        if (!this.isTerminalClose(code) && !this.stopped) {
-          this.scheduleReconnect();
-        }
-        reject(error);
-      };
-      socket.on("error", failBeforeHello);
-      socket.on("message", onMessageBeforeHello);
-      socket.on("close", onCloseBeforeHello);
-    });
-  }
-  async handleRawMessage(data) {
-    await this.handleFrame(decodeFrame(data.toString()));
-  }
-  async handleFrame(frame) {
-    if (frame.ack) {
-      const pending = this.pendingRequests.get(frame.ack);
-      if (pending) {
-        clearTimeout(pending.timeout);
-        this.pendingRequests.delete(frame.ack);
-        if (frame.type === "ERROR") {
-          pending.reject(new Error(readErrorMessage(frame.payload)));
-        } else {
-          pending.resolve(frame.payload);
-        }
-        return;
-      }
-    }
-    if (frame.type === "PING") {
-      const pong = createFrame("PONG", { clientTime: Date.now() });
-      pong.ack = frame.id;
-      this.sendFrame(pong);
-      return;
-    }
-    if (frame.type === "PONG" || frame.type === "HELLO" || frame.type === "RESUME_DONE") {
-      return;
-    }
-    await this.options.onFrame?.(frame, this);
-  }
-  startHeartbeat(helloFrame) {
-    this.clearHeartbeat();
-    const intervalMs = this.options.heartbeatIntervalMs ?? readPingInterval(helloFrame.payload) ?? 2e4;
-    this.heartbeatTimer = setInterval(() => {
-      if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
-        return;
-      }
-      this.sendFrame(createFrame("PING", { clientTime: Date.now() }));
-    }, intervalMs);
-  }
-  handleClose(code) {
-    this.clearHeartbeat();
-    this.rejectPending(new Error(`CoolClaw WSS connection closed: ${code}`));
-    if (this.stopped || this.isTerminalClose(code)) {
-      return;
-    }
-    this.scheduleReconnect();
-  }
-  scheduleReconnect() {
-    this.clearReconnect();
-    const delayMs = this.options.reconnectDelayMs ?? 1e3;
-    this.reconnectTimer = setTimeout(() => {
-      if (this.stopped) return;
-      this.connect().catch((error) => {
-        if (!this.stopped) {
-          this.rejectPending(error instanceof Error ? error : new Error(String(error)));
-          this.scheduleReconnect();
-        }
-      });
-    }, delayMs);
-  }
-  clearHeartbeat() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = void 0;
-    }
-  }
-  clearReconnect() {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = void 0;
-    }
-  }
-  rejectPending(error) {
-    for (const pending of this.pendingRequests.values()) {
-      clearTimeout(pending.timeout);
-      pending.reject(error);
-    }
-    this.pendingRequests.clear();
-  }
-  isTerminalClose(code) {
-    return code === 4001 || code === 4002 || code === 4003 || code === 4004 || code === 4005;
-  }
-};
-function readPingInterval(payload) {
-  if (!isRecord4(payload) || typeof payload.pingIntervalMs !== "number" || payload.pingIntervalMs <= 0) {
-    return void 0;
-  }
-  return payload.pingIntervalMs;
-}
-function readErrorMessage(payload) {
-  if (isRecord4(payload) && typeof payload.message === "string") {
-    return payload.message;
-  }
-  return "CoolClaw request failed";
-}
-function isRecord4(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/channel.ts
-var coolclawChannelPlugin = {
-  id: "coolclaw",
-  meta: {
-    id: "coolclaw",
-    label: "CoolClaw",
-    selectionLabel: "CoolClaw",
-    docsPath: "/plugins/coolclaw",
-    blurb: "Connect OpenClaw to the CoolClaw/Riddle chat platform."
-  },
-  channels: ["coolclaw"],
-  channel: {
-    id: "coolclaw",
-    label: "CoolClaw",
-    docsPath: "/plugins/coolclaw",
-    blurb: "Connect OpenClaw to the CoolClaw/Riddle chat platform."
-  },
-  capabilities: {
-    chatTypes: ["direct", "group"]
-  },
-  config: {
-    listAccountIds(cfg) {
-      return Object.keys(cfg.channels?.coolclaw?.accounts ?? {});
-    },
-    resolveAccount(cfg, accountId = "default") {
-      return cfg.channels?.coolclaw?.accounts?.[accountId ?? "default"] ?? {};
-    },
-    defaultAccountId() {
-      return "default";
-    },
-    isConfigured(account) {
-      return Boolean(account.gatewayUrl && account.agentId && (account.tokenSecretRef || "tokenSecret" in account));
-    },
-    isEnabled(account) {
-      return account?.enabled !== false;
-    },
-    describeAccount(account) {
-      return {
-        accountId: "default",
-        name: account.name,
-        enabled: account.enabled !== false,
-        configured: Boolean(account.gatewayUrl && account.agentId && (account.tokenSecretRef || "tokenSecret" in account)),
-        gatewayUrl: account.gatewayUrl,
-        agentId: account.agentId,
-        tokenConfigured: Boolean(account.tokenSecretRef || "tokenSecret" in account),
-        allowFromCount: account.allowFrom?.length ?? 0,
-        dmPolicy: account.dmPolicy ?? "allowlist"
-      };
-    }
-  },
-  resolver: {
-    async resolveTargets({ inputs }) {
-      return inputs.map((input) => {
-        try {
-          const normalized = normalizeCoolclawTarget(input);
-          const [, type, id] = normalized.split(":");
-          parseCoolclawTarget(normalized);
-          return { input, resolved: true, id: normalized, name: `${type}:${id}` };
-        } catch (error) {
-          return { input, resolved: false, note: error instanceof Error ? error.message : String(error) };
-        }
-      });
-    }
-  },
-  messaging: {
-    normalizeTarget(raw) {
-      try {
-        const normalized = normalizeCoolclawTarget(raw);
-        parseCoolclawTarget(normalized);
-        return normalized;
-      } catch {
-        return void 0;
-      }
-    },
-    inferTargetChatType({ to }) {
-      return inferCoolclawTargetChatType(to);
-    },
-    targetResolver: {
-      hint: "Use coolclaw:human:<id>, coolclaw:agent:<id>, or coolclaw:group:<id>.",
-      looksLikeId(raw, normalized) {
-        return isCoolclawTargetId(raw, normalized);
-      },
-      resolveTarget({ input, normalized, preferredKind }) {
-        return resolveCoolclawMessagingTarget(normalized || input, preferredKind);
-      }
-    }
-  },
-  outbound: {
-    deliveryMode: "direct",
-    resolveTarget({ to }) {
-      if (!to) {
-        return { ok: false, error: new Error("CoolClaw target is required") };
-      }
-      try {
-        const normalized = normalizeCoolclawTarget(to);
-        parseCoolclawTarget(normalized);
-        return { ok: true, to: normalized };
-      } catch (error) {
-        return { ok: false, error: error instanceof Error ? error : new Error(String(error)) };
-      }
-    },
-    async sendText(ctx) {
-      const account = coolclawChannelPlugin.config.resolveAccount(ctx.cfg, ctx.accountId);
-      const token = await resolveAccountToken(account);
-      if (!account.gatewayUrl || !account.agentId || !token) {
-        throw new Error("CoolClaw account is not fully configured");
-      }
-      const client = new CoolclawWsClient({
-        gatewayUrl: account.gatewayUrl,
-        agentId: account.agentId,
-        token,
-        pluginVersion: "0.1.0",
-        ackStore: new InMemoryAckStore(),
-        accountKey: `coolclaw:${ctx.accountId ?? "default"}`
-      });
-      await client.start();
-      try {
-        const messageId = await sendText({ client, target: ctx.to, text: ctx.text });
-        return {
-          channel: "coolclaw",
-          messageId,
-          conversationId: ctx.to,
-          timestamp: Date.now()
-        };
-      } finally {
-        await client.stop();
-      }
-    }
-  },
-  status(source) {
-    return getCoolclawStatus(source);
-  },
-  gateway: {
-    async startAccount(ctx) {
-      const account = coolclawChannelPlugin.config.resolveAccount(ctx.cfg, ctx.accountId);
-      const token = await resolveAccountToken(account);
-      if (!account.gatewayUrl || !account.agentId || !token) {
-        ctx.log?.error(`[${ctx.accountId}] CoolClaw account is not fully configured`);
-        return;
-      }
-      const accountKey = `coolclaw:${ctx.accountId ?? "default"}`;
-      const ackStore = new FileAckStore();
-      ctx.setStatus({ accountId: ctx.accountId, status: "connecting" });
-      ctx.log?.info(`[${ctx.accountId}] starting CoolClaw provider (${account.gatewayUrl})`);
-      const client = new CoolclawWsClient({
-        gatewayUrl: account.gatewayUrl,
-        agentId: account.agentId,
-        token,
-        pluginVersion: "0.1.0",
-        ackStore,
-        accountKey,
-        onFrame: async (frame, wsClient) => {
-          try {
-            await handleInboundFrame({
-              frame,
-              accountKey,
-              ackStore,
-              accountConfig: { allowFrom: account.allowFrom, dmPolicy: account.dmPolicy },
-              dispatch: async (envelope) => {
-                if (!ctx.channelRuntime) {
-                  ctx.log?.warn("channelRuntime not available; skipping dispatch");
-                  return;
-                }
-                try {
-                  const isGroup = envelope.conversationId.startsWith("group:");
-                  const peer = isGroup ? { kind: "group", id: envelope.group?.groupId ?? envelope.conversationId } : { kind: "direct", id: envelope.conversationId };
-                  const route = ctx.channelRuntime.routing?.resolveAgentRoute ? await ctx.channelRuntime.routing.resolveAgentRoute({
-                    cfg: ctx.cfg,
-                    channel: "coolclaw",
-                    accountId: ctx.accountId,
-                    peer
-                  }) : { agentId: "main", sessionKey: `coolclaw:${envelope.conversationId}` };
-                  const storePath = ctx.channelRuntime.session?.resolveStorePath ? ctx.channelRuntime.session.resolveStorePath(ctx.cfg.session?.store, { agentId: route.agentId }) : "/tmp/openclaw/sessions";
-                  const senderLabel = envelope.sender ? `${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}` : "unknown";
-                  let deliveryTarget;
-                  if (envelope.group) {
-                    deliveryTarget = `coolclaw:group:${envelope.group.groupId}`;
-                  } else if (envelope.sender) {
-                    deliveryTarget = `coolclaw:${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}`;
-                  } else {
-                    deliveryTarget = normalizeCoolclawTarget(envelope.conversationId);
-                  }
-                  const agentHint = envelope.metadata?.agentHint;
-                  const bodyForAgent = agentHint ? envelope.text + agentHint : envelope.text;
-                  const ctxPayload = ctx.channelRuntime.reply.finalizeInboundContext({
-                    Body: envelope.text,
-                    BodyForAgent: bodyForAgent,
-                    RawBody: envelope.text,
-                    CommandBody: envelope.text,
-                    From: `coolclaw:${senderLabel}`,
-                    To: deliveryTarget,
-                    SessionKey: route.sessionKey,
-                    AccountId: ctx.accountId,
-                    ChatType: isGroup ? "channel" : "direct",
-                    CommandAuthorized: true,
-                    Provider: "coolclaw",
-                    Surface: "coolclaw",
-                    Channel: "coolclaw",
-                    Peer: peer,
-                    Mentioned: envelope.shouldReply
-                  });
-                  if (ctx.channelRuntime.session?.recordSessionMetaFromInbound) {
-                    await ctx.channelRuntime.session.recordSessionMetaFromInbound({
-                      storePath,
-                      sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
-                      ctx: ctxPayload
-                    });
-                  }
-                  if (ctx.channelRuntime.session?.updateLastRoute) {
-                    const sessionKey = ctxPayload.SessionKey ?? route.sessionKey;
-                    const lastRouteCtx = {
-                      storePath,
-                      sessionKey,
-                      deliveryContext: {
-                        channel: "coolclaw",
-                        to: deliveryTarget,
-                        accountId: ctx.accountId ?? void 0
-                      },
-                      ctx: ctxPayload
-                    };
-                    try {
-                      await ctx.channelRuntime.session.updateLastRoute(lastRouteCtx);
-                    } catch (err) {
-                      ctx.log?.warn(
-                        `updateLastRoute failed: ${err instanceof Error ? err.message : String(err)}`
-                      );
-                    }
-                    const mainSessionKey = route.mainSessionKey;
-                    if (mainSessionKey && mainSessionKey !== sessionKey) {
-                      try {
-                        await ctx.channelRuntime.session.updateLastRoute({
-                          ...lastRouteCtx,
-                          sessionKey: mainSessionKey,
-                          ctx: void 0
-                        });
-                      } catch (err) {
-                        ctx.log?.warn(
-                          `updateLastRoute (main) failed: ${err instanceof Error ? err.message : String(err)}`
-                        );
-                      }
-                    }
-                  }
-                  await ctx.channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
-                    ctx: ctxPayload,
-                    cfg: ctx.cfg,
-                    dispatcherOptions: {
-                      deliver: async (payload) => {
-                        if (!payload.text) return;
-                        try {
-                          let replyTarget;
-                          if (envelope.group) {
-                            replyTarget = `coolclaw:group:${envelope.group.groupId}`;
-                          } else if (envelope.sender) {
-                            replyTarget = `coolclaw:${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}`;
-                          } else {
-                            replyTarget = normalizeCoolclawTarget(envelope.conversationId);
-                          }
-                          await sendText({ client: wsClient, target: replyTarget, text: payload.text });
-                        } catch (err) {
-                          ctx.log?.error(`Failed to deliver reply: ${err instanceof Error ? err.message : String(err)}`);
-                        }
-                      },
-                      onError: (err, info) => {
-                        ctx.log?.error(`Reply dispatch error: ${err instanceof Error ? err.message : String(err)}`, info);
-                      }
-                    }
-                  });
-                } catch (err) {
-                  ctx.log?.error(`Inbound dispatch error: ${err instanceof Error ? err.message : String(err)}`);
-                }
-              },
-              sendAck: async (ackFrame) => {
-                try {
-                  wsClient.sendFrame(ackFrame);
-                  ctx.log?.debug(`ACK sent: type=${ackFrame.type} lastAckedSeq=${ackFrame.payload?.lastAckedSeq}`);
-                } catch (err) {
-                  ctx.log?.warn(`ACK send failed: ${err instanceof Error ? err.message : String(err)}`);
-                }
-              }
-            });
-          } catch (err) {
-            ctx.log?.error(`Frame handling error: ${err instanceof Error ? err.message : String(err)}`);
-          }
-        }
-      });
-      await client.start();
-      ctx.setStatus({ accountId: ctx.accountId, status: "connected" });
-      ctx.log?.info(`[${ctx.accountId}] CoolClaw provider connected`);
-      await new Promise((resolve) => {
-        ctx.abortSignal.addEventListener("abort", () => resolve(), { once: true });
-      });
-      await client.stop();
-      ctx.setStatus({ accountId: ctx.accountId, status: "disconnected" });
-      ctx.log?.info(`[${ctx.accountId}] CoolClaw provider stopped`);
-    }
-  }
-};
-
-export {
-  defaultBindingFile,
-  defaultOpenClawConfigFile,
-  defaultTokenFile,
-  loadBinding,
-  touchBinding,
-  saveBinding,
-  saveAgentToken,
-  readTokenRef,
-  normalizeGatewayUrl,
-  coolclawChannelPlugin
-};