@agentchatme/openclaw 0.2.0

package/dist/setup-entry.cjs

@@ -0,0 +1,920 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var channelCore = require('openclaw/plugin-sdk/channel-core');
+var zod = require('zod');
+
+// src/channel.setup.ts
+var reconnectConfigSchema = zod.z.object({
+  initialBackoffMs: zod.z.number().int().min(100).max(1e4).default(1e3),
+  maxBackoffMs: zod.z.number().int().min(1e3).max(3e5).default(3e4),
+  jitterRatio: zod.z.number().min(0).max(1).default(0.2)
+}).strict();
+var pingConfigSchema = zod.z.object({
+  intervalMs: zod.z.number().int().min(5e3).max(12e4).default(3e4),
+  timeoutMs: zod.z.number().int().min(1e3).max(3e4).default(1e4)
+}).strict();
+var outboundConfigSchema = zod.z.object({
+  maxInFlight: zod.z.number().int().min(1).max(1e4).default(256),
+  sendTimeoutMs: zod.z.number().int().min(1e3).max(6e4).default(15e3)
+}).strict();
+var observabilityConfigSchema = zod.z.object({
+  logLevel: zod.z.enum(["trace", "debug", "info", "warn", "error"]).default("info"),
+  redactKeys: zod.z.array(zod.z.string()).default(["apiKey", "authorization", "cookie", "set-cookie"])
+}).strict();
+var agentHandleSchema = zod.z.string().regex(/^[a-z0-9_.-]{3,32}$/, "handle must be 3-32 chars, lowercase alphanumeric + . _ -");
+var agentchatChannelConfigSchema = zod.z.object({
+  apiBase: zod.z.string().url().default("https://api.agentchat.me"),
+  apiKey: zod.z.string().min(20, "apiKey looks too short for an AgentChat API key"),
+  agentHandle: agentHandleSchema.optional(),
+  // `.prefault({})` — Zod 4 idiom: when the key is missing from input, parse
+  // `{}` through the inner schema so its own per-field defaults kick in.
+  // Using `.default({})` here fails in Zod 4 because the output type's fields
+  // are non-optional once the inner schema has defaults.
+  reconnect: reconnectConfigSchema.prefault({}),
+  ping: pingConfigSchema.prefault({}),
+  outbound: outboundConfigSchema.prefault({}),
+  observability: observabilityConfigSchema.prefault({})
+}).strict();
+function parseChannelConfig(input) {
+  return agentchatChannelConfigSchema.parse(input);
+}
+
+// src/setup-client.ts
+var DEFAULT_API_BASE = "https://api.agentchat.me";
+var DEFAULT_TIMEOUT_MS = 1e4;
+async function validateApiKey(apiKey, opts = {}) {
+  if (!apiKey || typeof apiKey !== "string") {
+    return { ok: false, reason: "unauthorized", message: "API key is empty" };
+  }
+  const base = (opts.apiBase ?? DEFAULT_API_BASE).replace(/\/+$/, "");
+  const url = `${base}/v1/agents/me`;
+  const controller = new AbortController();
+  const fetchImpl = opts.fetch ?? fetch;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let res;
+  try {
+    res = await fetchImpl(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json"
+      },
+      signal: controller.signal
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const unreachable = err instanceof Error && (err.name === "AbortError" || /ECONN|ETIMEDOUT|ENOTFOUND|EAI_AGAIN/i.test(message));
+    return {
+      ok: false,
+      reason: unreachable ? "unreachable" : "network-error",
+      message: `agentchat: GET /v1/agents/me failed: ${message}`
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+  if (res.status === 401) {
+    return { ok: false, reason: "unauthorized", status: 401, message: "API key is invalid or revoked" };
+  }
+  if (res.status === 403) {
+    return { ok: false, reason: "forbidden", status: 403, message: "API key lacks permission to read /agents/me" };
+  }
+  if (res.status === 410) {
+    return { ok: false, reason: "deleted", status: 410, message: "Agent account has been deleted" };
+  }
+  if (res.status >= 500) {
+    return { ok: false, reason: "server-error", status: res.status, message: `AgentChat API returned ${res.status}` };
+  }
+  if (!res.ok) {
+    return {
+      ok: false,
+      reason: "server-error",
+      status: res.status,
+      message: `AgentChat API returned ${res.status}`
+    };
+  }
+  const body = await res.json().catch(() => null);
+  const email = typeof body?.email === "string" ? body.email : typeof body?.email_masked === "string" ? body.email_masked : null;
+  if (!body || typeof body.handle !== "string" || email === null || typeof body.created_at !== "string") {
+    return {
+      ok: false,
+      reason: "unexpected-shape",
+      status: res.status,
+      message: "AgentChat /agents/me returned an unrecognized shape"
+    };
+  }
+  return {
+    ok: true,
+    agent: {
+      handle: body.handle,
+      displayName: typeof body.display_name === "string" ? body.display_name : null,
+      email,
+      createdAt: body.created_at
+    }
+  };
+}
+async function registerAgentStart(input, opts = {}) {
+  const res = await post("/v1/register", input, opts);
+  if (res.kind === "network") {
+    return { ok: false, reason: "network-error", message: res.message };
+  }
+  if (res.kind === "timeout") {
+    return { ok: false, reason: "network-error", message: "request timed out" };
+  }
+  const body = res.body ?? {};
+  if (res.status === 200) {
+    if (typeof body.pending_id !== "string") {
+      return {
+        ok: false,
+        reason: "server-error",
+        status: 200,
+        message: "AgentChat /register returned no pending_id"
+      };
+    }
+    return { ok: true, pendingId: body.pending_id };
+  }
+  const code = typeof body.code === "string" ? body.code : "";
+  const message = typeof body.message === "string" ? body.message : `status ${res.status}`;
+  if (res.status === 400 && code === "INVALID_HANDLE") return { ok: false, reason: "invalid-handle", message, status: 400 };
+  if (res.status === 400 && code === "VALIDATION_ERROR") return { ok: false, reason: "validation", message, status: 400 };
+  if (res.status === 409 && code === "HANDLE_TAKEN") return { ok: false, reason: "handle-taken", message, status: 409 };
+  if (res.status === 409 && code === "EMAIL_TAKEN") return { ok: false, reason: "email-taken", message, status: 409 };
+  if (res.status === 409 && code === "EMAIL_IS_OWNER") return { ok: false, reason: "email-is-owner", message, status: 409 };
+  if (res.status === 409 && code === "EMAIL_EXHAUSTED") return { ok: false, reason: "email-exhausted", message, status: 409 };
+  if (res.status === 429) {
+    return {
+      ok: false,
+      reason: "rate-limited",
+      message,
+      status: 429,
+      retryAfterSeconds: res.retryAfterSeconds
+    };
+  }
+  if (res.status >= 500 || code === "OTP_FAILED") return { ok: false, reason: "otp-failed", message, status: res.status };
+  return { ok: false, reason: "server-error", status: res.status, message };
+}
+async function registerAgentVerify(input, opts = {}) {
+  const res = await post("/v1/register/verify", { pending_id: input.pendingId, code: input.code }, opts);
+  if (res.kind === "network") return { ok: false, reason: "network-error", message: res.message };
+  if (res.kind === "timeout") return { ok: false, reason: "network-error", message: "request timed out" };
+  const body = res.body ?? {};
+  if (res.status === 201) {
+    const agent = body.agent;
+    if (typeof body.api_key !== "string" || !agent || typeof agent.handle !== "string" || typeof agent.email !== "string" || typeof agent.created_at !== "string") {
+      return {
+        ok: false,
+        reason: "unexpected-shape",
+        status: 201,
+        message: "AgentChat /register/verify returned an unrecognized shape"
+      };
+    }
+    return {
+      ok: true,
+      apiKey: body.api_key,
+      agent: {
+        handle: agent.handle,
+        displayName: typeof agent.display_name === "string" ? agent.display_name : null,
+        email: agent.email,
+        createdAt: agent.created_at
+      }
+    };
+  }
+  const code = typeof body.code === "string" ? body.code : "";
+  const message = typeof body.message === "string" ? body.message : `status ${res.status}`;
+  if (res.status === 400 && code === "EXPIRED") return { ok: false, reason: "expired", message, status: 400 };
+  if (res.status === 400 && code === "INVALID_CODE") return { ok: false, reason: "invalid-code", message, status: 400 };
+  if (res.status === 400 && code === "VALIDATION_ERROR") return { ok: false, reason: "validation", message, status: 400 };
+  if (res.status === 409 && code === "HANDLE_TAKEN") return { ok: false, reason: "handle-taken", message, status: 409 };
+  if (res.status === 409 && code === "EMAIL_TAKEN") return { ok: false, reason: "email-taken", message, status: 409 };
+  if (res.status === 409 && code === "EMAIL_IS_OWNER") return { ok: false, reason: "email-is-owner", message, status: 409 };
+  if (res.status === 429) {
+    return { ok: false, reason: "rate-limited", message, status: 429, retryAfterSeconds: res.retryAfterSeconds };
+  }
+  return { ok: false, reason: "server-error", status: res.status, message };
+}
+async function post(path, body, opts) {
+  const base = (opts.apiBase ?? DEFAULT_API_BASE).replace(/\/+$/, "");
+  const url = `${base}${path}`;
+  const controller = new AbortController();
+  const fetchImpl = opts.fetch ?? fetch;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json" },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    const parsed = await res.json().catch(() => null);
+    const retryAfterHeader = res.headers.get("retry-after");
+    const retryAfterSeconds = retryAfterHeader ? Number(retryAfterHeader) : void 0;
+    return {
+      kind: "http",
+      status: res.status,
+      body: parsed,
+      retryAfterSeconds: Number.isFinite(retryAfterSeconds) ? retryAfterSeconds : void 0
+    };
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") return { kind: "timeout" };
+    return { kind: "network", message: err instanceof Error ? err.message : String(err) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/setup-wizard.ts
+var HANDLE_PATTERN = /^[a-z0-9_.-]{3,32}$/;
+var MIN_API_KEY_LENGTH = 20;
+var OTP_ATTEMPTS = 3;
+function readSection(cfg) {
+  const channels = cfg?.channels;
+  const sec = channels?.[AGENTCHAT_CHANNEL_ID];
+  return sec && typeof sec === "object" && !Array.isArray(sec) ? sec : void 0;
+}
+function readAccountRaw(cfg, accountId) {
+  const sec = readSection(cfg);
+  if (!sec) return void 0;
+  const accounts = sec.accounts;
+  if (accounts && typeof accounts === "object" && !Array.isArray(accounts)) {
+    const entry = accounts[accountId];
+    if (entry && typeof entry === "object") return entry;
+  }
+  if (accountId === AGENTCHAT_DEFAULT_ACCOUNT_ID) {
+    const { accounts: _accounts, ...rest } = sec;
+    return rest;
+  }
+  return void 0;
+}
+function readAccountApiKey(cfg, accountId) {
+  const raw = readAccountRaw(cfg, accountId);
+  const value = raw?.apiKey;
+  return typeof value === "string" && value.length >= MIN_API_KEY_LENGTH ? value : void 0;
+}
+function readAccountApiBase(cfg, accountId) {
+  const raw = readAccountRaw(cfg, accountId);
+  const value = raw?.apiBase;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function writeAccountPatch(cfg, accountId, patch) {
+  const channels = {
+    ...cfg?.channels ?? {}
+  };
+  const existing = channels[AGENTCHAT_CHANNEL_ID];
+  const section = existing && typeof existing === "object" && !Array.isArray(existing) ? { ...existing } : {};
+  const clean = {};
+  if (patch.apiKey !== void 0) clean.apiKey = patch.apiKey;
+  if (patch.apiBase !== void 0) clean.apiBase = patch.apiBase;
+  if (patch.agentHandle !== void 0) clean.agentHandle = patch.agentHandle;
+  const hasAccountsMap = typeof section.accounts === "object" && section.accounts !== null && !Array.isArray(section.accounts);
+  if (accountId === AGENTCHAT_DEFAULT_ACCOUNT_ID && !hasAccountsMap) {
+    Object.assign(section, clean);
+  } else {
+    const accounts = {
+      ...section.accounts ?? {}
+    };
+    const prev = typeof accounts[accountId] === "object" && accounts[accountId] !== null ? accounts[accountId] : {};
+    accounts[accountId] = { ...prev, ...clean };
+    section.accounts = accounts;
+  }
+  channels[AGENTCHAT_CHANNEL_ID] = section;
+  return { ...cfg, channels };
+}
+function isAccountConfigured(cfg, accountId) {
+  return Boolean(readAccountApiKey(cfg, accountId ?? AGENTCHAT_DEFAULT_ACCOUNT_ID));
+}
+async function promptApiKey(prompter) {
+  const value = await prompter.text({
+    message: "Paste your AgentChat API key",
+    placeholder: "ac_live_...",
+    validate: (v) => {
+      const trimmed = v.trim();
+      if (!trimmed) return "API key is required";
+      if (trimmed.length < MIN_API_KEY_LENGTH)
+        return `Looks too short (${trimmed.length} chars \u2014 expect \u2265${MIN_API_KEY_LENGTH})`;
+      return void 0;
+    }
+  });
+  return value.trim();
+}
+async function promptEmail(prompter) {
+  const value = await prompter.text({
+    message: "Your email address (for OTP verification)",
+    placeholder: "you@example.com",
+    validate: (v) => {
+      const trimmed = v.trim();
+      if (!trimmed) return "Email is required";
+      if (!/.+@.+\..+/.test(trimmed)) return "Not a valid email address";
+      return void 0;
+    }
+  });
+  return value.trim();
+}
+async function promptHandle(prompter, initial) {
+  const value = await prompter.text({
+    message: "Pick a handle for your agent",
+    placeholder: "alice",
+    initialValue: initial,
+    validate: (v) => {
+      const trimmed = v.trim().toLowerCase();
+      if (!trimmed) return "Handle is required";
+      if (!HANDLE_PATTERN.test(trimmed))
+        return "3\u201332 chars; lowercase a-z / 0-9 / dot / underscore / dash";
+      return void 0;
+    }
+  });
+  return value.trim().toLowerCase();
+}
+async function promptOtp(prompter) {
+  const value = await prompter.text({
+    message: "Enter the 6-digit code we emailed you",
+    placeholder: "123456",
+    validate: (v) => /^\d{6}$/.test(v.trim()) ? void 0 : "6-digit numeric code required"
+  });
+  return value.trim();
+}
+async function promptOptionalText(prompter, message, placeholder) {
+  const value = await prompter.text({
+    message,
+    placeholder,
+    validate: () => void 0
+  });
+  return value.trim();
+}
+function describeRegisterStartFailure(r) {
+  switch (r.reason) {
+    case "invalid-handle":
+      return "That handle is not valid. Use 3\u201332 chars, lowercase a-z / 0-9 / . _ -.";
+    case "handle-taken":
+      return "That handle is already taken. Pick another.";
+    case "email-taken":
+      return "That email already has an agent. Sign in with the existing key instead, or use a different email.";
+    case "email-is-owner":
+      return "That email is reserved. Use a different address.";
+    case "email-exhausted":
+      return "This email has hit the per-address agent limit. Use a different email or delete an old agent.";
+    case "rate-limited":
+      return r.retryAfterSeconds ? `Too many attempts. Try again in ${r.retryAfterSeconds}s.` : "Too many attempts. Try again in a few minutes.";
+    case "otp-failed":
+      return "Could not send the verification email. Check the address and retry.";
+    case "network-error":
+      return `Network error: ${r.message}`;
+    case "validation":
+      return `Validation error: ${r.message}`;
+    case "server-error":
+      return `AgentChat API error (${r.status ?? "??"}): ${r.message}`;
+  }
+}
+function describeRegisterVerifyFailure(r) {
+  switch (r.reason) {
+    case "expired":
+      return "That code has expired. We'll request a new one \u2014 restart registration.";
+    case "invalid-code":
+      return "Wrong code. Check the email and try again.";
+    case "rate-limited":
+      return r.retryAfterSeconds ? `Too many attempts. Wait ${r.retryAfterSeconds}s before retrying.` : "Too many attempts. Try again in a few minutes.";
+    case "handle-taken":
+      return "Someone else just took that handle. Restart and pick another.";
+    case "email-taken":
+      return "That email was registered by someone else between these steps. Start over.";
+    case "email-is-owner":
+      return "That email is reserved.";
+    case "network-error":
+      return `Network error: ${r.message}`;
+    case "unexpected-shape":
+      return `Server returned an unexpected response (${r.status ?? "??"}). Try again shortly.`;
+    case "validation":
+      return `Validation error: ${r.message}`;
+    case "server-error":
+      return `AgentChat API error (${r.status ?? "??"}): ${r.message}`;
+  }
+}
+async function runHaveKeyFlow(cfg, accountId, prompter, apiBase) {
+  const apiKey = await promptApiKey(prompter);
+  const progress = prompter.progress("Validating key against AgentChat\u2026");
+  const result = await validateApiKey(apiKey, { apiBase });
+  if (!result.ok) {
+    progress.stop("Key rejected.");
+    await prompter.note(
+      [
+        `AgentChat rejected the key (${result.reason}):`,
+        `  ${result.message}`,
+        "",
+        result.reason === "unauthorized" || result.reason === "deleted" ? "The key is invalid, revoked, or the agent was deleted. Grab a fresh key from agentchat.me/dashboard." : result.reason === "unreachable" || result.reason === "network-error" ? "Could not reach the API. Check your network, then run setup again." : "Try again, or pick the register flow."
+      ].join("\n"),
+      "Validation failed"
+    );
+    return runNewAccountFlow(cfg, accountId, prompter, apiBase);
+  }
+  progress.stop(`Authenticated as @${result.agent.handle}.`);
+  const next = writeAccountPatch(cfg, accountId, {
+    apiKey,
+    agentHandle: result.agent.handle,
+    ...apiBase ? { apiBase } : {}
+  });
+  await prompter.note(
+    [
+      `Connected to AgentChat as @${result.agent.handle}.`,
+      `Email: ${result.agent.email}`,
+      result.agent.displayName ? `Display name: ${result.agent.displayName}` : void 0
+    ].filter((v) => Boolean(v)).join("\n"),
+    "AgentChat configured"
+  );
+  return { cfg: next };
+}
+async function runRegisterFlow(cfg, accountId, prompter, apiBase) {
+  await prompter.note(
+    [
+      "We will email a 6-digit code to verify ownership of this address.",
+      "The email is hashed server-side and used only for account recovery."
+    ].join("\n"),
+    "New-agent registration"
+  );
+  const email = await promptEmail(prompter);
+  const handle = await promptHandle(prompter);
+  const displayName = await promptOptionalText(
+    prompter,
+    "Display name (optional, press Enter to skip)",
+    handle
+  );
+  const description = await promptOptionalText(
+    prompter,
+    "Short description of your agent (optional)",
+    "Research assistant that summarises papers"
+  );
+  const startProgress = prompter.progress("Requesting OTP\u2026");
+  const start = await registerAgentStart(
+    {
+      email,
+      handle,
+      displayName: displayName || void 0,
+      description: description || void 0
+    },
+    { apiBase }
+  );
+  if (!start.ok) {
+    startProgress.stop("Registration could not start.");
+    await prompter.note(describeRegisterStartFailure(start), "Registration failed");
+    const retry = await prompter.confirm({
+      message: start.reason === "handle-taken" || start.reason === "invalid-handle" ? "Try a different handle?" : "Try again?",
+      initialValue: true
+    });
+    if (!retry) return { cfg };
+    return runRegisterFlow(cfg, accountId, prompter, apiBase);
+  }
+  startProgress.stop(`OTP sent to ${email}.`);
+  const pendingId = start.pendingId;
+  for (let attempt = 1; attempt <= OTP_ATTEMPTS; attempt += 1) {
+    const code = await promptOtp(prompter);
+    const verifyProgress = prompter.progress("Verifying code\u2026");
+    const verify = await registerAgentVerify({ pendingId, code }, { apiBase });
+    if (verify.ok) {
+      verifyProgress.stop(`Verified. Agent @${verify.agent.handle} created.`);
+      const next = writeAccountPatch(cfg, accountId, {
+        apiKey: verify.apiKey,
+        agentHandle: verify.agent.handle,
+        ...apiBase ? { apiBase } : {}
+      });
+      await prompter.note(
+        [
+          "Your AgentChat API key has been written to config.",
+          "",
+          `  handle: @${verify.agent.handle}`,
+          `  email:  ${verify.agent.email}`,
+          "",
+          "Keep the key safe \u2014 it authenticates sends as this agent.",
+          "You can rotate it any time from agentchat.me/dashboard."
+        ].join("\n"),
+        "Registration complete"
+      );
+      return { cfg: next };
+    }
+    verifyProgress.stop(`Attempt ${attempt}/${OTP_ATTEMPTS} failed (${verify.reason}).`);
+    await prompter.note(describeRegisterVerifyFailure(verify), "Code rejected");
+    if (verify.reason === "expired") {
+      return runRegisterFlow(cfg, accountId, prompter, apiBase);
+    }
+    if (verify.reason !== "invalid-code") {
+      const retry = await prompter.confirm({
+        message: "Start over with different details?",
+        initialValue: true
+      });
+      if (!retry) return { cfg };
+      return runRegisterFlow(cfg, accountId, prompter, apiBase);
+    }
+  }
+  await prompter.note(
+    "Too many invalid codes. Restart setup to request a new one.",
+    "Registration aborted"
+  );
+  return { cfg };
+}
+async function runEditFlow(cfg, accountId, prompter) {
+  const currentKey = readAccountApiKey(cfg, accountId);
+  const currentBase = readAccountApiBase(cfg, accountId);
+  const choice = await prompter.select({
+    message: "AgentChat is already configured. What would you like to do?",
+    options: [
+      {
+        value: "validate",
+        label: "Re-validate the current key",
+        hint: "Hit /agents/me to confirm it still authenticates"
+      },
+      {
+        value: "rotate",
+        label: "Rotate to a new API key",
+        hint: "Paste a freshly generated key or register a new agent"
+      },
+      {
+        value: "change-base",
+        label: "Change API base URL",
+        hint: "Only for self-hosted AgentChat deployments"
+      },
+      { value: "skip", label: "Leave as is", hint: "No changes" }
+    ],
+    initialValue: "validate"
+  });
+  if (choice === "skip") return { cfg };
+  if (choice === "validate") {
+    if (!currentKey) {
+      await prompter.note("No API key is currently set.", "Nothing to validate");
+      return runNewAccountFlow(cfg, accountId, prompter, currentBase);
+    }
+    const progress = prompter.progress("Probing /agents/me\u2026");
+    const result = await validateApiKey(currentKey, { apiBase: currentBase });
+    if (result.ok) {
+      progress.stop(`Still authenticated as @${result.agent.handle}.`);
+      return { cfg };
+    }
+    progress.stop("Key no longer works.");
+    await prompter.note(`${result.message} [reason=${result.reason}]`, "Re-validation failed");
+    const doRotate = await prompter.confirm({
+      message: "Rotate to a new key now?",
+      initialValue: true
+    });
+    if (doRotate) return runNewAccountFlow(cfg, accountId, prompter, currentBase);
+    return { cfg };
+  }
+  if (choice === "rotate") {
+    return runNewAccountFlow(cfg, accountId, prompter, currentBase);
+  }
+  const nextBase = await promptOptionalText(
+    prompter,
+    "New API base URL (blank to reset to default)",
+    currentBase ?? "https://api.agentchat.me"
+  );
+  if (nextBase) {
+    try {
+      const url = new URL(nextBase);
+      if (url.protocol !== "https:" && url.protocol !== "http:") {
+        await prompter.note("API base must use http:// or https://. Not updated.", "Ignored");
+        return { cfg };
+      }
+    } catch {
+      await prompter.note("Not a valid URL. API base not updated.", "Ignored");
+      return { cfg };
+    }
+  }
+  const next = writeAccountPatch(cfg, accountId, { apiBase: nextBase || void 0 });
+  await prompter.note(
+    nextBase ? `API base set to ${nextBase}` : "API base reset to default",
+    "Updated"
+  );
+  return { cfg: next };
+}
+async function runNewAccountFlow(cfg, accountId, prompter, apiBase) {
+  const choice = await prompter.select({
+    message: "How do you want to connect this agent?",
+    options: [
+      {
+        value: "register",
+        label: "Register a new agent (email + OTP)",
+        hint: "Mint a fresh API key \u2014 ~60 seconds"
+      },
+      {
+        value: "have-key",
+        label: "I already have an API key",
+        hint: "Paste ac_live_..."
+      }
+    ],
+    initialValue: "register"
+  });
+  if (choice === "have-key") return runHaveKeyFlow(cfg, accountId, prompter, apiBase);
+  return runRegisterFlow(cfg, accountId, prompter, apiBase);
+}
+var agentchatSetupWizard = {
+  channel: AGENTCHAT_CHANNEL_ID,
+  resolveShouldPromptAccountIds: () => false,
+  status: {
+    configuredLabel: "connected",
+    unconfiguredLabel: "needs API key",
+    configuredHint: "configured",
+    unconfiguredHint: "needs agent credentials",
+    configuredScore: 2,
+    unconfiguredScore: 0,
+    resolveConfigured: ({ cfg, accountId }) => isAccountConfigured(cfg, accountId),
+    resolveStatusLines: async ({ cfg, accountId, configured }) => {
+      if (!configured) return ["AgentChat: needs API key \u2014 run setup to register or paste one"];
+      const id = accountId ?? AGENTCHAT_DEFAULT_ACCOUNT_ID;
+      const key = readAccountApiKey(cfg, id);
+      const apiBase = readAccountApiBase(cfg, id);
+      if (!key) return ["AgentChat: configured (no key visible)"];
+      try {
+        const result = await validateApiKey(key, { apiBase, timeoutMs: 3e3 });
+        if (result.ok) return [`AgentChat: connected as @${result.agent.handle}`];
+        return [`AgentChat: configured (live probe failed: ${result.reason})`];
+      } catch {
+        return ["AgentChat: configured (live probe unreachable)"];
+      }
+    }
+  },
+  introNote: {
+    title: "AgentChat",
+    lines: [
+      "A messaging platform for AI agents \u2014 handle-based routing, realtime WebSocket,",
+      "typed error taxonomy, idempotent sends.",
+      "",
+      "You can paste an existing API key, or register a new agent inline (email + OTP)."
+    ]
+  },
+  prepare: async ({ cfg, accountId, credentialValues }) => {
+    const flow = isAccountConfigured(cfg, accountId) ? "edit" : "new";
+    return { credentialValues: { ...credentialValues, _flow: flow } };
+  },
+  credentials: [],
+  finalize: async ({ cfg, accountId, prompter, credentialValues }) => {
+    const rawFlow = credentialValues._flow;
+    const flow = rawFlow === "edit" ? "edit" : "new";
+    const apiBase = readAccountApiBase(cfg, accountId);
+    return flow === "edit" ? await runEditFlow(cfg, accountId, prompter) : await runNewAccountFlow(cfg, accountId, prompter, apiBase);
+  },
+  completionNote: {
+    title: "AgentChat is ready",
+    lines: [
+      "The channel runtime will auto-connect on the next `openclaw` boot.",
+      "Messages addressed to your handle arrive over WebSocket; sends go out",
+      "over HTTPS with at-least-once + idempotent semantics."
+    ]
+  },
+  disable: (cfg) => {
+    const channels = {
+      ...cfg?.channels ?? {}
+    };
+    const existing = channels[AGENTCHAT_CHANNEL_ID];
+    const section = existing && typeof existing === "object" && !Array.isArray(existing) ? { ...existing } : {};
+    section.enabled = false;
+    channels[AGENTCHAT_CHANNEL_ID] = section;
+    return { ...cfg, channels };
+  }
+};
+
+// src/channel.ts
+var AGENTCHAT_CHANNEL_ID = "agentchat";
+var AGENTCHAT_DEFAULT_ACCOUNT_ID = "default";
+var MIN_API_KEY_LENGTH2 = 20;
+function readChannelSection(cfg) {
+  const channels = cfg?.channels;
+  const section = channels?.[AGENTCHAT_CHANNEL_ID];
+  return section && typeof section === "object" && !Array.isArray(section) ? section : void 0;
+}
+function readAccountRaw2(section, accountId) {
+  if (!section) return void 0;
+  const { accounts } = section;
+  if (accounts && typeof accounts === "object" && !Array.isArray(accounts)) {
+    const entry = accounts[accountId];
+    if (entry && typeof entry === "object") return entry;
+  }
+  if (accountId === AGENTCHAT_DEFAULT_ACCOUNT_ID) {
+    const { accounts: _accounts, ...rest } = section;
+    return rest;
+  }
+  return void 0;
+}
+function splitEnabledFromRaw(raw) {
+  if (!raw) return { enabled: true, forParse: void 0 };
+  const { enabled, ...rest } = raw;
+  return { enabled: enabled !== false, forParse: rest };
+}
+function isApiKeyPresent(value) {
+  return typeof value === "string" && value.length >= MIN_API_KEY_LENGTH2;
+}
+var uiHints = {
+  apiKey: {
+    label: "AgentChat API key",
+    placeholder: "ac_live_...",
+    sensitive: true,
+    help: "Obtain from AgentChat dashboard \u2192 Settings \u2192 API keys."
+  },
+  apiBase: {
+    label: "API base URL",
+    placeholder: "https://api.agentchat.me",
+    help: "Override only when targeting a self-hosted AgentChat instance.",
+    advanced: true
+  },
+  agentHandle: {
+    label: "Agent handle",
+    placeholder: "my-agent",
+    help: "3\u201332 chars, lowercase alphanumeric plus . _ -"
+  },
+  reconnect: { label: "Reconnect backoff", advanced: true },
+  ping: { label: "WebSocket ping cadence", advanced: true },
+  outbound: { label: "Outbound send tuning", advanced: true },
+  observability: { label: "Logs & metrics", advanced: true }
+};
+var agentchatPlugin = {
+  id: AGENTCHAT_CHANNEL_ID,
+  meta: {
+    id: AGENTCHAT_CHANNEL_ID,
+    label: "AgentChat",
+    selectionLabel: "AgentChat (messaging platform for agents)",
+    detailLabel: "AgentChat",
+    docsPath: "/channels/agentchat",
+    docsLabel: "agentchat",
+    blurb: "connect your agent to the AgentChat messaging platform \u2014 handles, contacts, groups, presence, attachments.",
+    systemImage: "message",
+    markdownCapable: true,
+    order: 100
+  },
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    media: true,
+    reactions: false,
+    edit: false,
+    unsend: true,
+    reply: true,
+    threads: false,
+    nativeCommands: false
+  },
+  reload: {
+    configPrefixes: [`channels.${AGENTCHAT_CHANNEL_ID}.`]
+  },
+  configSchema: channelCore.buildChannelConfigSchema(agentchatChannelConfigSchema, { uiHints }),
+  setupWizard: agentchatSetupWizard,
+  config: {
+    listAccountIds(cfg) {
+      const section = readChannelSection(cfg);
+      if (!section) return [];
+      const { accounts } = section;
+      if (accounts && typeof accounts === "object" && !Array.isArray(accounts)) {
+        const ids = Object.keys(accounts);
+        if (ids.length > 0) return ids;
+      }
+      const hasFlatFields = typeof section.apiKey === "string" || typeof section.apiBase === "string" || typeof section.agentHandle === "string";
+      return hasFlatFields ? [AGENTCHAT_DEFAULT_ACCOUNT_ID] : [];
+    },
+    resolveAccount(cfg, accountId) {
+      const id = accountId ?? AGENTCHAT_DEFAULT_ACCOUNT_ID;
+      const section = readChannelSection(cfg);
+      const raw = readAccountRaw2(section, id);
+      const { enabled, forParse } = splitEnabledFromRaw(raw);
+      let config = null;
+      let parseError = null;
+      if (forParse && Object.keys(forParse).length > 0) {
+        try {
+          config = parseChannelConfig(forParse);
+        } catch (e) {
+          parseError = e instanceof Error ? e.message : String(e);
+        }
+      }
+      const configured = Boolean(config && isApiKeyPresent(config.apiKey));
+      return { accountId: id, enabled, configured, config, parseError };
+    },
+    defaultAccountId() {
+      return AGENTCHAT_DEFAULT_ACCOUNT_ID;
+    },
+    isEnabled(account) {
+      return account.enabled;
+    },
+    disabledReason(account) {
+      return account.enabled ? "" : "channel disabled via channels.agentchat.enabled=false";
+    },
+    isConfigured(account) {
+      return account.configured;
+    },
+    unconfiguredReason(account) {
+      if (account.parseError) return `config invalid: ${account.parseError}`;
+      if (!account.config) return "missing channels.agentchat configuration";
+      if (!isApiKeyPresent(account.config.apiKey)) return "missing or too-short channels.agentchat.apiKey";
+      return "";
+    },
+    hasConfiguredState({ cfg }) {
+      const section = readChannelSection(cfg);
+      if (!section) return false;
+      const { accounts } = section;
+      if (accounts && typeof accounts === "object" && !Array.isArray(accounts)) {
+        for (const entry of Object.values(accounts)) {
+          if (entry && typeof entry === "object") {
+            const candidate = entry.apiKey;
+            if (isApiKeyPresent(candidate)) return true;
+          }
+        }
+      }
+      return isApiKeyPresent(section.apiKey);
+    },
+    describeAccount(account) {
+      return {
+        accountId: account.accountId,
+        enabled: account.enabled,
+        configured: account.configured,
+        linked: account.configured
+      };
+    }
+  },
+  setup: {
+    /**
+     * Pre-write gate: cheap, sync check that the caller supplied an API key
+     * that's at least plausibly shaped. Real authentication happens in
+     * `afterAccountConfigWritten` via a live /agents/me probe.
+     */
+    validateInput({ input }) {
+      if (typeof input.token !== "string" || input.token.trim().length === 0) {
+        return "apiKey is required \u2014 pass via --token or run the register flow";
+      }
+      if (input.token.length < MIN_API_KEY_LENGTH2) {
+        return `apiKey looks too short (got ${input.token.length} chars, expect \u2265${MIN_API_KEY_LENGTH2})`;
+      }
+      if (typeof input.url === "string" && input.url.length > 0) {
+        try {
+          const parsed = new URL(input.url);
+          if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+            return "apiBase must be http(s) \u2014 e.g. https://api.agentchat.me";
+          }
+        } catch {
+          return "apiBase is not a valid URL";
+        }
+      }
+      return null;
+    },
+    applyAccountConfig({ cfg, accountId, input }) {
+      const channels = {
+        ...cfg?.channels ?? {}
+      };
+      const currentSection = channels[AGENTCHAT_CHANNEL_ID];
+      const section = currentSection && typeof currentSection === "object" && !Array.isArray(currentSection) ? { ...currentSection } : {};
+      const patch = {};
+      if (typeof input.token === "string" && input.token.length > 0) patch.apiKey = input.token;
+      if (typeof input.url === "string" && input.url.length > 0) patch.apiBase = input.url;
+      if (accountId === AGENTCHAT_DEFAULT_ACCOUNT_ID && !section.accounts) {
+        Object.assign(section, patch);
+      } else {
+        const accounts = {
+          ...section.accounts ?? {}
+        };
+        const prevAccount = typeof accounts[accountId] === "object" && accounts[accountId] !== null ? accounts[accountId] : {};
+        accounts[accountId] = { ...prevAccount, ...patch };
+        section.accounts = accounts;
+      }
+      channels[AGENTCHAT_CHANNEL_ID] = section;
+      return { ...cfg, channels };
+    },
+    /**
+     * Post-write probe: call `GET /v1/agents/me` with the key we just wrote
+     * so the operator sees a clear "✓ authenticated as @handle" on success
+     * — or a specific failure reason (invalid, revoked, unreachable) they
+     * can act on *before* the runtime starts flapping reconnects in prod.
+     *
+     * Never throws: setup-time UX is "warn and proceed". If the probe can't
+     * reach the API (airgapped CI, corp proxy during first boot), we still
+     * want the config written so the user can retry without reconfiguring.
+     */
+    async afterAccountConfigWritten({ cfg, accountId, input, runtime }) {
+      const apiKey = typeof input.token === "string" ? input.token : void 0;
+      if (!apiKey) return;
+      const apiBase = typeof input.url === "string" && input.url.length > 0 ? input.url : void 0;
+      const logger = runtime?.logger;
+      try {
+        const result = await validateApiKey(apiKey, { apiBase });
+        if (result.ok) {
+          logger?.info?.(
+            `[agentchat:${accountId}] authenticated as @${result.agent.handle} (${result.agent.email})`
+          );
+        } else {
+          logger?.warn?.(
+            `[agentchat:${accountId}] api key did not pass live check (${result.reason}): ${result.message}`
+          );
+        }
+      } catch (err) {
+        logger?.warn?.(
+          `[agentchat:${accountId}] live key validation failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+};
+channelCore.defineChannelPluginEntry({
+  id: AGENTCHAT_CHANNEL_ID,
+  name: "AgentChat",
+  description: "Connect OpenClaw agents to the AgentChat messaging platform.",
+  plugin: agentchatPlugin
+});
+
+// src/channel.setup.ts
+var agentchatSetupEntry = channelCore.defineSetupPluginEntry(agentchatPlugin);
+
+exports.agentchatSetupEntry = agentchatSetupEntry;
+exports.agentchatSetupPlugin = agentchatPlugin;
+exports.default = agentchatSetupEntry;
+//# sourceMappingURL=setup-entry.cjs.map
+//# sourceMappingURL=setup-entry.cjs.map