@coolclaw/coolclaw 0.1.0

package/dist/chunk-LUUSK4S5.js

@@ -0,0 +1,289 @@
+import {
+  coolclawChannelPlugin,
+  defaultBindingFile,
+  defaultOpenClawConfigFile,
+  defaultTokenFile,
+  loadBinding,
+  normalizeGatewayUrl,
+  readTokenRef,
+  saveAgentToken,
+  saveBinding,
+  touchBinding
+} from "./chunk-4WOJKMUY.js";
+
+// src/identity.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+var BEGIN_MARKER = "<!-- BEGIN_RIDDLE_IDENTITY -->";
+var END_MARKER = "<!-- END_RIDDLE_IDENTITY -->";
+async function updateRiddleIdentitySummary(summary) {
+  await mkdir(summary.workspaceDir, { recursive: true });
+  const identityFile = path.join(summary.workspaceDir, "IDENTITY.md");
+  const existing = await readExisting(identityFile);
+  const block = [
+    BEGIN_MARKER,
+    "## Riddle Platform",
+    "",
+    `Riddle Agent ID: ${summary.agentId}`,
+    `Riddle Gateway: ${normalizeGatewayUrl(summary.gatewayUrl)}`,
+    `Riddle Binding: ${summary.bindingFile}`,
+    "Messaging: handled by the CoolClaw OpenClaw channel.",
+    "Non-message platform actions: handled by the Riddle skill.",
+    END_MARKER
+  ].join("\n");
+  const next = replaceBlock(existing, block);
+  await writeFile(identityFile, next.endsWith("\n") ? next : `${next}
+`);
+}
+async function readExisting(identityFile) {
+  try {
+    return await readFile(identityFile, "utf8");
+  } catch {
+    return "";
+  }
+}
+function replaceBlock(existing, block) {
+  const start = existing.indexOf(BEGIN_MARKER);
+  const end = existing.indexOf(END_MARKER);
+  if (start >= 0 && end >= start) {
+    return `${existing.slice(0, start).trimEnd()}
+
+${block}
+${existing.slice(end + END_MARKER.length).trimStart()}`;
+  }
+  return existing.trim() ? `${existing.trimEnd()}
+
+${block}
+` : `${block}
+`;
+}
+
+// src/openclaw-config.ts
+import { mkdir as mkdir2, readFile as readFile2, rename, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+async function patchCoolclawAccountConfig(patch) {
+  const config = await readOpenClawConfig(patch.configPath);
+  const channels = ensureRecord(config, "channels");
+  const coolclaw = ensureRecord(channels, "coolclaw");
+  const accounts = ensureRecord(coolclaw, "accounts");
+  const account = {
+    name: `Riddle Agent ${patch.agentId}`,
+    enabled: true,
+    gatewayUrl: normalizeGatewayUrl(patch.gatewayUrl),
+    agentId: patch.agentId,
+    tokenSecretRef: patch.tokenSecretRef,
+    dmPolicy: patch.dmPolicy ?? "allowlist"
+  };
+  if (patch.allowFrom && patch.allowFrom.length > 0) {
+    account.allowFrom = patch.allowFrom;
+  }
+  accounts.default = account;
+  await writeOpenClawConfig(patch.configPath, config);
+}
+async function readOpenClawConfig(configPath) {
+  try {
+    const parsed = JSON.parse(await readFile2(configPath, "utf8"));
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function writeOpenClawConfig(configPath, config) {
+  await mkdir2(path2.dirname(configPath), { recursive: true });
+  const tmpFile = `${configPath}.${process.pid}.tmp`;
+  await writeFile2(tmpFile, `${JSON.stringify(config, null, 2)}
+`);
+  await rename(tmpFile, configPath);
+}
+function ensureRecord(parent, key) {
+  const existing = parent[key];
+  if (isRecord(existing)) return existing;
+  const created = {};
+  parent[key] = created;
+  return created;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/setup.ts
+async function registerAgent(baseUrl, input) {
+  const res = await fetch(`${normalizeGatewayUrl(baseUrl)}/api/agent/register`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(input)
+  });
+  const body = await res.json();
+  if (!res.ok || body.code !== 200) {
+    throw new Error(body.message ?? `Agent register failed: ${res.status}`);
+  }
+  if (!body.data?.agentId || !body.data.token) {
+    throw new Error("Agent register response missing agentId or token");
+  }
+  return {
+    agentId: String(body.data.agentId),
+    token: String(body.data.token)
+  };
+}
+async function validateAgentToken(baseUrl, token) {
+  const res = await fetch(`${normalizeGatewayUrl(baseUrl)}/api/users/me`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) return false;
+  const body = await res.json();
+  return body.code === 200 && body.data?.identityType === "AGENT";
+}
+async function runCoolclawSetup(options = {}) {
+  const gatewayUrl = normalizeGatewayUrl(options.gatewayUrl ?? "https://agits-xa.baidu.com/riddle");
+  const bindingFile = options.bindingFile ?? defaultBindingFile();
+  const openclawConfigPath = options.openclawConfigPath ?? defaultOpenClawConfigFile();
+  const existingBinding = await loadBinding(bindingFile);
+  const existingToken = await readTokenRef(existingBinding.tokenRef);
+  if (options.dryRun) {
+    return {
+      mode: "dry-run",
+      gatewayUrl,
+      agentId: existingBinding.agentId,
+      bindingFile,
+      openclawConfigPath,
+      tokenSavedTo: tokenFileFromBinding(existingBinding, bindingFile)
+    };
+  }
+  const canReuse = !options.forceRegister && existingBinding.agentId.length > 0 && Boolean(existingToken) && await validateAgentToken(gatewayUrl, existingToken);
+  const binding = canReuse ? existingBinding : await registerAndPersistBinding({
+    gatewayUrl,
+    bindingFile,
+    registration: options.registration ?? defaultRegistrationInput()
+  });
+  const tokenFile = tokenFileFromBinding(binding, bindingFile);
+  if (!options.dryRun) {
+    await patchCoolclawAccountConfig({
+      configPath: openclawConfigPath,
+      gatewayUrl,
+      agentId: binding.agentId,
+      tokenSecretRef: binding.tokenRef ?? `file://${tokenFile}`,
+      allowFrom: options.allowFrom,
+      dmPolicy: options.dmPolicy
+    });
+    if (options.workspaceDir) {
+      await updateRiddleIdentitySummary({
+        workspaceDir: options.workspaceDir,
+        agentId: binding.agentId,
+        gatewayUrl,
+        bindingFile,
+        tokenRef: binding.tokenRef ?? void 0
+      });
+    }
+  }
+  return {
+    mode: options.dryRun ? "dry-run" : canReuse ? "reuse" : "register",
+    gatewayUrl,
+    agentId: binding.agentId,
+    bindingFile,
+    openclawConfigPath,
+    tokenSavedTo: tokenFile
+  };
+}
+async function registerAndPersistBinding(input) {
+  const registered = await registerAgent(input.gatewayUrl, input.registration);
+  const valid = await validateAgentToken(input.gatewayUrl, registered.token);
+  if (!valid) {
+    throw new Error("Newly registered Riddle token did not validate as an AGENT token");
+  }
+  const tokenFile = defaultTokenFile(input.bindingFile, registered.agentId);
+  await saveAgentToken(tokenFile, registered.token);
+  const binding = touchBinding({
+    agentId: registered.agentId,
+    tokenRef: `file://${tokenFile}`,
+    runtimeType: "openclaw",
+    lastAckedSeq: 0
+  });
+  await saveBinding(input.bindingFile, binding);
+  return binding;
+}
+function tokenFileFromBinding(binding, bindingFile) {
+  if (binding.tokenRef?.startsWith("file://")) {
+    return binding.tokenRef.slice("file://".length);
+  }
+  return defaultTokenFile(bindingFile, binding.agentId);
+}
+function defaultRegistrationInput() {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(4, 12);
+  return {
+    name: `RiddleAgent-${stamp}`,
+    bio: "OpenClaw agent connected through CoolClaw channel.",
+    tags: JSON.stringify(["assistant", "openclaw", "coolclaw"])
+  };
+}
+
+// src/cli.ts
+function registerCoolclawCli(options) {
+  const setup = options.setup ?? runCoolclawSetup;
+  const coolclaw = options.program.command("coolclaw").description("Manage the CoolClaw/Riddle channel");
+  coolclaw.command("setup").description("Register or reuse a Riddle agent and configure the CoolClaw channel").option("--gateway-url <url>", "Riddle gateway URL", "https://agits-xa.baidu.com/riddle").option("--binding-file <path>", "Shared Riddle binding file", defaultBindingFile()).option("--openclaw-config <path>", "OpenClaw config file").option("--workspace-dir <path>", "OpenClaw agent workspace directory", options.workspaceDir).option("--name <name>", "Riddle agent display name").option("--bio <bio>", "Riddle agent bio").option("--tags <tags>", "Riddle agent tags").option("--allow-from <items>", "Comma-separated DM allowlist").option("--dm-policy <policy>", "DM policy: allowlist or pairing", "allowlist").option("--force-register", "Register a new Riddle agent even if a valid binding exists", false).option("--dry-run", "Resolve setup inputs without writing local files", false).option("-y, --yes", "Accept defaults for non-interactive setup", false).action(async (...args) => {
+    const rawOptions = readActionOptions(args);
+    const result = await setup(toSetupOptions(rawOptions));
+    console.log(JSON.stringify(result, null, 2));
+  });
+  coolclaw.command("status").description("Show the shared Riddle binding location used by CoolClaw").action(() => {
+    console.log(JSON.stringify({ bindingFile: defaultBindingFile() }, null, 2));
+  });
+}
+function readActionOptions(args) {
+  const candidate = args.at(-1);
+  return typeof candidate === "object" && candidate !== null ? candidate : {};
+}
+function toSetupOptions(raw) {
+  return {
+    gatewayUrl: stringOption(raw.gatewayUrl),
+    bindingFile: stringOption(raw.bindingFile),
+    openclawConfigPath: stringOption(raw.openclawConfig),
+    workspaceDir: stringOption(raw.workspaceDir),
+    registration: {
+      name: stringOption(raw.name) ?? "CoolClaw Agent",
+      bio: stringOption(raw.bio) ?? "OpenClaw agent connected through CoolClaw channel.",
+      tags: stringOption(raw.tags) ?? JSON.stringify(["assistant", "openclaw", "coolclaw"])
+    },
+    allowFrom: splitCsv(stringOption(raw.allowFrom)),
+    dmPolicy: raw.dmPolicy === "pairing" ? "pairing" : "allowlist",
+    forceRegister: Boolean(raw.forceRegister),
+    dryRun: Boolean(raw.dryRun),
+    yes: Boolean(raw.yes)
+  };
+}
+function stringOption(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : 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;
+}
+
+// index.ts
+var index_default = {
+  id: "coolclaw",
+  name: "CoolClaw Channel",
+  description: "CoolClaw/Riddle messaging channel for OpenClaw",
+  register(api) {
+    api.registerChannel({ plugin: coolclawChannelPlugin });
+    api.registerCli?.(
+      ({ program, workspaceDir }) => {
+        registerCoolclawCli({ program, workspaceDir });
+      },
+      {
+        descriptors: [
+          {
+            name: "coolclaw",
+            description: "Manage the CoolClaw/Riddle channel",
+            hasSubcommands: true
+          }
+        ]
+      }
+    );
+  }
+};
+
+export {
+  index_default
+};

package/dist/cli-metadata.d.ts

@@ -0,0 +1,6 @@
+import _default from './index.js';
+import './channel-BozkcSms.js';
+
+
+
+export { _default as default };

package/dist/cli-metadata.js

@@ -0,0 +1,10 @@
+import {
+  index_default
+} from "./chunk-LUUSK4S5.js";
+import "./chunk-4WOJKMUY.js";
+
+// cli-metadata.ts
+var cli_metadata_default = index_default;
+export {
+  cli_metadata_default as default
+};

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { c as coolclawChannelPlugin } from './channel-BozkcSms.js';
+
+type OpenClawPluginApi = {
+    registerChannel(input: {
+        plugin: typeof coolclawChannelPlugin;
+    }): void;
+    registerCli?(registrar: (ctx: {
+        program: unknown;
+        workspaceDir?: string;
+    }) => void | Promise<void>, opts?: {
+        descriptors?: Array<{
+            name: string;
+            description: string;
+            hasSubcommands: boolean;
+        }>;
+    }): void;
+};
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    register(api: OpenClawPluginApi): void;
+};
+
+export { _default as default };

package/dist/index.js

@@ -0,0 +1,7 @@
+import {
+  index_default
+} from "./chunk-LUUSK4S5.js";
+import "./chunk-4WOJKMUY.js";
+export {
+  index_default as default
+};

package/dist/setup-entry.d.ts

@@ -0,0 +1,5 @@
+import { c as coolclawChannelPlugin } from './channel-BozkcSms.js';
+
+
+
+export { coolclawChannelPlugin as default };

package/dist/setup-entry.js

@@ -0,0 +1,9 @@
+import {
+  coolclawChannelPlugin
+} from "./chunk-4WOJKMUY.js";
+
+// setup-entry.ts
+var setup_entry_default = coolclawChannelPlugin;
+export {
+  setup_entry_default as default
+};

package/openclaw.plugin.json

@@ -0,0 +1,21 @@
+{
+  "id": "coolclaw",
+  "channels": [
+    "coolclaw"
+  ],
+  "channelEnvVars": {
+    "coolclaw": [
+      "COOLCLAW_GATEWAY_URL",
+      "COOLCLAW_AGENT_ID",
+      "COOLCLAW_AGENT_TOKEN",
+      "COOLCLAW_AGENT_TOKEN_SECRET_REF",
+      "COOLCLAW_ALLOW_FROM",
+      "COOLCLAW_DM_POLICY"
+    ]
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@coolclaw/coolclaw",
+  "version": "0.1.0",
+  "description": "OpenClaw native channel plugin for Riddle/CoolClaw chat.",
+  "type": "module",
+  "files": [
+    "dist",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "openclaw-channel",
+    "coolclaw",
+    "riddle",
+    "chat",
+    "websocket"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/coolclaw/riddle.git",
+    "directory": "plugins/openclaw-coolclaw-channel"
+  },
+  "scripts": {
+    "build": "tsup index.ts setup-entry.ts cli-metadata.ts --format esm --dts --out-dir dist --clean",
+    "test": "vitest run",
+    "lint": "tsc --noEmit"
+  },
+  "dependencies": {
+    "ws": "latest",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "@types/ws": "latest",
+    "tsup": "latest",
+    "typescript": "latest",
+    "vitest": "latest"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.3.13"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ],
+    "setupEntry": "./setup-entry.ts",
+    "runtimeSetupEntry": "./dist/setup-entry.js",
+    "install": {
+      "npmSpec": "@coolclaw/coolclaw",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.3.13"
+    },
+    "channel": {
+      "id": "coolclaw",
+      "label": "CoolClaw",
+      "docsPath": "/plugins/coolclaw",
+      "blurb": "Connect OpenClaw to the CoolClaw/Riddle chat platform."
+    },
+    "compat": {
+      "pluginApi": ">=2026.3.13",
+      "minGatewayVersion": "2026.3.13"
+    },
+    "build": {
+      "openclawVersion": "2026.4.20",
+      "pluginSdkVersion": "2026.4.20"
+    }
+  }
+}