@coolclaw/coolclaw 0.2.10 → 0.3.1

package/dist/chunk-D4S6TJVL.js

@@ -0,0 +1,123 @@
+import {
+  coolclawChannelPlugin,
+  setCoolclawRuntime
+} from "./chunk-BWFXW7X6.js";
+import {
+  runCoolclawSetup
+} from "./chunk-A54AF634.js";
+import {
+  CoolclawConfigSchema,
+  defaultBindingFile
+} from "./chunk-Q3NF4NWE.js";
+
+// index.ts
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/channel-core";
+import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
+
+// 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", "open").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("--no-restart", "Skip automatic gateway restart after setup").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) {
+  const explicitName = stringOption(raw.name);
+  const explicitBio = stringOption(raw.bio);
+  return {
+    gatewayUrl: stringOption(raw.gatewayUrl),
+    bindingFile: stringOption(raw.bindingFile),
+    openclawConfigPath: stringOption(raw.openclawConfig),
+    workspaceDir: stringOption(raw.workspaceDir),
+    registration: explicitName || explicitBio ? {
+      name: explicitName ?? "CoolClaw Agent",
+      bio: explicitBio ?? "OpenClaw agent connected through CoolClaw channel.",
+      tags: stringOption(raw.tags) ?? JSON.stringify(["assistant", "openclaw", "coolclaw"])
+    } : void 0,
+    allowFrom: splitCsv(stringOption(raw.allowFrom)),
+    dmPolicy: raw.dmPolicy === "pairing" ? "pairing" : "open",
+    forceRegister: Boolean(raw.forceRegister),
+    dryRun: Boolean(raw.dryRun),
+    autoRestart: raw.restart !== false,
+    // --no-restart 时为 false，默认 true
+    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;
+}
+
+// src/compat.ts
+var SUPPORTED_HOST_MIN = "2026.3.22";
+function assertHostCompatibility(hostVersion) {
+  if (!hostVersion || hostVersion === "unknown") return;
+  if (isHostVersionSupported(hostVersion)) return;
+  throw new Error(
+    `This version of @coolclaw/coolclaw requires OpenClaw >=${SUPPORTED_HOST_MIN}, but found ${hostVersion}. Please upgrade OpenClaw:
+  npm install -g openclaw@latest
+Then reinstall the plugin:
+  openclaw plugins install @coolclaw/coolclaw
+
+Or use the one-command installer (requires @coolclaw/coolclaw-cli published to npm):
+  npx @coolclaw/coolclaw-cli install`
+  );
+}
+function isHostVersionSupported(hostVersion) {
+  const clean = hostVersion.split("-")[0];
+  const host = clean.split(".").map(Number);
+  const min = SUPPORTED_HOST_MIN.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (host[i] > min[i]) return true;
+    if (host[i] < min[i]) return false;
+  }
+  return true;
+}
+
+// index.ts
+var entry = defineChannelPluginEntry({
+  id: "coolclaw",
+  name: "CoolClaw",
+  description: "CoolClaw/Riddle messaging channel for OpenClaw",
+  configSchema: buildChannelConfigSchema(CoolclawConfigSchema),
+  plugin: coolclawChannelPlugin,
+  registerCliMetadata(api) {
+    api.registerCli(
+      ({ program }) => {
+        registerCoolclawCli({ program });
+      },
+      {
+        descriptors: [
+          {
+            name: "coolclaw",
+            description: "Manage the CoolClaw/Riddle channel",
+            hasSubcommands: true
+          }
+        ]
+      }
+    );
+  },
+  registerFull(api) {
+    assertHostCompatibility(api.runtime?.version);
+    setCoolclawRuntime(api.runtime);
+  }
+});
+var index_default = entry;
+
+export {
+  index_default
+};

package/dist/chunk-Q3NF4NWE.js

@@ -0,0 +1,105 @@
+// src/binding.ts
+import { mkdir, readFile, rename, writeFile, chmod } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+var RIDDLE_BINDING_VERSION = 1;
+function defaultBindingFile(home = homedir()) {
+  return path.join(home, ".config", "coolclaw", "agent_binding.json");
+}
+function defaultOpenClawConfigFile(home = homedir()) {
+  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
+import { z } from "zod";
+var CoolclawConfigSchema = z.object({
+  gatewayUrl: z.string().url().optional().describe("Riddle gateway URL"),
+  agentId: z.string().optional().describe("Riddle agent ID"),
+  tokenSecretRef: z.string().optional().describe("Token secret reference (file:// or env:)"),
+  allowFrom: z.array(z.string()).optional().describe("Allowed sender IDs"),
+  dmPolicy: z.enum(["allowlist", "pairing", "open"]).optional().describe("DM access policy"),
+  enabled: z.boolean().optional().describe("Whether the account is enabled"),
+  name: z.string().optional().describe("Account display name")
+});
+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}`;
+}
+async function resolveAccountToken(account) {
+  if (account.tokenSecret) return account.tokenSecret;
+  return readTokenRef(account.tokenSecretRef);
+}
+
+export {
+  defaultBindingFile,
+  defaultOpenClawConfigFile,
+  defaultTokenFile,
+  loadBinding,
+  touchBinding,
+  saveBinding,
+  saveAgentToken,
+  readTokenRef,
+  CoolclawConfigSchema,
+  normalizeGatewayUrl,
+  buildWsUrl,
+  resolveAccountToken
+};