@inetafrica/open-claudia 2.14.4 → 2.14.6

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## v2.14.6
+- **`/channel add kazee` started from the inline "Add Kazee" button now completes — owner-capture confirm lands on the operator's channel, not on Kazee.** The wizard's owner-confirm prompt (*"Is this you — the owner?"*) is meant to go back to the channel the operator ran `/channel` from, via `channel-wizard.sayToOrigin`, which needs `session.origin` — captured from the envelope passed to `start()`. The typed `/channel add kazee` path (`handlers.js`) passed the envelope; the button path (`actions.js` `chn:add:kazee`) did **not**, so `origin` was null and the prompt fell back to ambient `io.send` scope — which, while processing the operator's inbound Kazee trigger message, is the Kazee room. The Yes/No/Skip buttons then rendered on Kazee, where a tap can never resolve the session: it's keyed by the operator's canonical id, but a Kazee tap resolves to the owner's *unlinked* Kazee user id (the very thing owner-capture is establishing) → `handleAction` finds no session → *"That setup step expired."* `actions.js` now passes the envelope to `wizard.start`, exactly like the typed path.
+- **`/channel remove` and the inline "Remove <id>" button now share one teardown, so they can't drift.** v2.14.5 made the typed `/channel remove` a complete teardown (adapter + `.env` + `people.unlinkAdapterHandles` + `identity.removeTransportIdentities`), but the button (`actions.js` `chn:rm:`) still ran the pre-v2.14.5 version that cleared only `.env` — so removing via the button left exactly the handle/identity residue v2.14.5 was built to clear. The full teardown is now a single `channel-wizard.removeChannel(id)` called by both entry points; callers only guard `telegram` and format `r.summary` / `r.error`. Net −10 lines.
+- **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds identically. Both fixes close divergences between the button and typed entry points of the owner-driven `/channel` flow — inert for deployments that never add/remove a channel. Full `npm test` green.
+
+## v2.14.5
+- **`/channel remove <id>` is now a complete teardown — a re-add starts from a genuinely clean slate.** Removal used to clear only the `.env` channel config (`CHANNELS` + the `KAZEE_*` keys), but the wizard's v2.14.4 owner-capture also links the owner's Kazee handle onto their people record (`people.linkHandle`) and mirrors an identity mapping into `identities.json` (`setIdentityMapping`). Those were left behind, so a subsequent `/channel add kazee` stacked on stale handle + identity state. `/channel remove` now also drops every handle for that transport across all people records (new `people.unlinkAdapterHandles`) and removes its identity mappings — channel→canonical links and preferred-channel pointers (new `identity.removeTransportIdentities`) — and clears the previously-orphaned `KAZEE_BOT_USER_ID`.
+- **The cleanup goes through the in-memory stores, so disk and the running process stay consistent.** `identities.json` is loaded once at boot into a shared in-memory object (`identity.js`), and `saveIdentities()` re-serializes that whole object on every write. Because `router.js` calls `autoLinkOwnerChannel` → `setIdentityMapping` → `saveIdentities` on each owner message, any entry lingering in memory is rewritten to disk continuously — so an out-of-band file edit can't stick, and a partial teardown leaves ghosts that reappear. Removing through the in-memory maps (then persisting) means the teardown holds. The `/channel remove` reply now reports what it cleared (e.g. `Removed channel: kazee — cleared 1 handle + identity links`).
+- **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds identically. Scoped entirely to the owner-driven `/channel remove` path — inert for deployments that never remove a channel. Full `npm test` green.
+
 ## v2.14.4
 - **The owner no longer gets asked to double-approve their own Kazee reply — split-brain owner resolution is fixed.** On Kazee a person is identified by `userId` while the room is `channelId` (the chat-document); the two differ. The auth layer already recognised the owner correctly (via `access.matchesTransportOwner` → `currentUserId()`), but the independent relationship guardrail re-derived ownership from `channelId` — which never equals the configured `KAZEE_OWNER_USER_ID` — and so classed the owner as *external*, escalating the owner's own approval a second time. `relationship.speakerFor` now takes an optional third `userId` and keys identity/owner classification off `speakerId = userId || channelId` (the person), while still replying/escalating to `channelId` (the room). The raw per-user id is threaded to every subprocess egress guard via a new `OC_CHANNEL_USER_ID` env var + loopback query/body param (`bin/cli.js`, `bin/entity.js`, `bin/tool.js`, `bin/loopback-client.js`, `core/io.js`, `core/loopback.js`, `core/system-prompt.js`). **On Telegram `userId === channelId` in DMs, so this is a strict no-op** for existing Telegram deployments.
 - **`/channel add kazee` now links the owner's Kazee handle at capture time.** Owner recognition previously lived only in the env/adapter (`KAZEE_OWNER_USER_ID`); the owner's people record had no Kazee handle, so the guardrail (which resolves through canonical identity) re-derived the operator as external. `finalizeOwner` now calls `people.linkHandle(owner.id, { adapter: "kazee", channelId: ownerUserId, … })` so the wizard's captured owner is recognised the same way the rest of the bot resolves identity — belt-and-suspenders with the `speakerFor` fix above.

package/core/actions.js

@@ -488,28 +488,12 @@ async function handleAction(envelope) {
   if (d.startsWith("chn:")) {
     if (!isChatOwner(envelope.channelId)) { await send("Owner only."); return; }
     const wizard = require("./channel-wizard");
-    const registry = require("./adapter-registry");
-    if (d === "chn:add:kazee") { await wizard.start(envelope.canonicalUserId, "kazee"); return; }
+    if (d === "chn:add:kazee") { await wizard.start(envelope.canonicalUserId, "kazee", envelope); return; }
     if (d.startsWith("chn:rm:")) {
       const id = d.slice("chn:rm:".length);
       if (id === "telegram") { await send("Refusing to remove the Telegram adapter."); return; }
-      const result = await registry.removeAdapter(id);
-      if (!result.ok) { await send(result.error); return; }
-      const { config, saveEnvKey } = require("./config");
-      const channels = (config.CHANNELS || "telegram").split(",").map((s) => s.trim()).filter(Boolean);
-      const kept = channels.filter((c) => c !== id && !c.startsWith(id + ":") && c !== id.split(":")[0]);
-      const next = kept.join(",") || "telegram";
-      saveEnvKey("CHANNELS", next);
-      config.CHANNELS = next;
-      if (id === "kazee") {
-        saveEnvKey("KAZEE_URL", "");
-        saveEnvKey("KAZEE_BOT_TOKEN", "");
-        saveEnvKey("KAZEE_OWNER_USER_ID", "");
-        config.KAZEE_URL = "";
-        config.KAZEE_BOT_TOKEN = "";
-        config.KAZEE_OWNER_USER_ID = "";
-      }
-      await send(`Removed channel: ${id}`);
+      const r = await wizard.removeChannel(id);
+      await send(r.ok ? r.summary : r.error);
       return;
     }
   }

package/core/channel-wizard.js

@@ -325,6 +325,37 @@ async function finalizeOwner(canonicalUserId, session, ownerUserId) {
   );
 }
 
+// Full teardown for a live channel, shared by the /channel remove command and
+// the inline "Remove <id>" button so the two entry points can't drift. Removes
+// the adapter, strips its keys from .env (so the change survives restart), and
+// drops its handles + identity mappings through the in-memory stores — a stale
+// handle/link otherwise survives in memory and gets rewritten on the next add,
+// which is what made a re-add feel un-clean. Callers guard "telegram" (their
+// own connection) and format r.summary / r.error for their channel.
+async function removeChannel(id) {
+  const result = await registry.removeAdapter(id);
+  if (!result.ok) return { ok: false, error: result.error };
+  const transport = id.split(":")[0];
+  const channels = (config.CHANNELS || "telegram").split(",").map((s) => s.trim()).filter(Boolean);
+  const kept = channels.filter((c) => c !== id && !c.startsWith(id + ":") && c !== transport);
+  saveEnvKey("CHANNELS", kept.join(",") || "telegram");
+  config.CHANNELS = kept.join(",") || "telegram";
+  if (transport === "kazee") {
+    for (const k of ["KAZEE_URL", "KAZEE_BOT_TOKEN", "KAZEE_OWNER_USER_ID", "KAZEE_BOT_USER_ID"]) {
+      saveEnvKey(k, "");
+      config[k] = "";
+    }
+  }
+  let unlinked = 0;
+  try { unlinked = people.unlinkAdapterHandles(transport).length; } catch (e) {}
+  let idsCleared = false;
+  try { idsCleared = require("./identity").removeTransportIdentities(transport); } catch (e) {}
+  const extra = (unlinked || idsCleared)
+    ? ` — cleared ${unlinked} handle${unlinked === 1 ? "" : "s"} + identity links`
+    : "";
+  return { ok: true, id, transport, unlinked, idsCleared, summary: `Removed channel: ${id}${extra}` };
+}
+
 module.exports = {
   isAwaiting,
   getSession,
@@ -334,5 +365,6 @@ module.exports = {
   handleText,
   handleAction,
   tryCaptureOwner,
+  removeChannel,
   validateKazee,
 };

package/core/handlers.js

@@ -1672,23 +1672,8 @@ register({
     if (removeMatch) {
       const id = removeMatch[1];
       if (id === "telegram") return send("Refusing to remove the Telegram adapter from a /channel command — that's your own connection.");
-      const result = await registry.removeAdapter(id);
-      if (!result.ok) return send(result.error);
-      // Strip from .env so the change survives restart.
-      const channels = (config.CHANNELS || "telegram").split(",").map((s) => s.trim()).filter(Boolean);
-      const kept = channels.filter((c) => c !== id && !c.startsWith(id + ":") && c !== id.split(":")[0]);
-      const next = kept.join(",") || "telegram";
-      saveEnvKey("CHANNELS", next);
-      config.CHANNELS = next;
-      if (id === "kazee") {
-        saveEnvKey("KAZEE_URL", "");
-        saveEnvKey("KAZEE_BOT_TOKEN", "");
-        saveEnvKey("KAZEE_OWNER_USER_ID", "");
-        config.KAZEE_URL = "";
-        config.KAZEE_BOT_TOKEN = "";
-        config.KAZEE_OWNER_USER_ID = "";
-      }
-      return send(`Removed channel: ${id}`);
+      const r = await wizard.removeChannel(id);
+      return send(r.ok ? r.summary : r.error);
     }
 
     send("Usage: /channel | /channel add kazee | /channel remove <id>");

package/core/identity.js

@@ -137,6 +137,25 @@ function setIdentityMapping(transport, channelId, canonicalUserId) {
   };
 }
 
+// Remove every identity mapping for a transport — used when a channel is torn
+// down (/channel remove) so no stale channel→canonical link or preferred-channel
+// pointer lingers to be rewritten to disk on the next identity write. Mutates
+// the in-memory map the whole process shares, THEN persists, so memory and disk
+// stay in sync (a disk-only edit would be resurrected by the cached object).
+function removeTransportIdentities(transport) {
+  const t = String(transport || "").toLowerCase();
+  if (!t) return false;
+  let changed = false;
+  for (const key of Object.keys(identities.channels)) {
+    if (key.slice(0, t.length + 1) === t + ":") { delete identities.channels[key]; changed = true; }
+  }
+  for (const [userId, pref] of Object.entries(identities.preferred)) {
+    if (pref && String(pref.transport || "").toLowerCase() === t) { delete identities.preferred[userId]; changed = true; }
+  }
+  if (changed) saveIdentities();
+  return changed;
+}
+
 module.exports = {
   identities,
   normalizeCanonicalUserId,
@@ -149,5 +168,6 @@ module.exports = {
   canonicalForTelegram,
   canonicalForStoredUserKey,
   setIdentityMapping,
+  removeTransportIdentities,
   saveIdentities,
 };

package/core/people.js

@@ -159,6 +159,30 @@ function unlinkHandle(personId, { adapter, channelId }) {
   return p;
 }
 
+// Remove every handle for a given adapter across ALL people records — used when
+// a channel is torn down (/channel remove) so no stranded handle survives to be
+// re-linked or re-mirrored on a later add. primaryChannel falls back to the next
+// remaining handle. Returns the ids of the people that were changed.
+function unlinkAdapterHandles(adapter) {
+  const a = String(adapter || "").toLowerCase();
+  if (!a) return [];
+  const all = load();
+  const affected = [];
+  for (const p of all) {
+    const before = (p.handles || []).length;
+    if (!before) continue;
+    p.handles = p.handles.filter((h) => h.adapter !== a);
+    if (p.handles.length === before) continue;
+    if (p.primaryChannel && p.primaryChannel.adapter === a) {
+      p.primaryChannel = p.handles[0] ? { adapter: p.handles[0].adapter, channelId: p.handles[0].channelId } : null;
+    }
+    p.updatedAt = nowIso();
+    affected.push(p.id);
+  }
+  if (affected.length) save(all);
+  return affected;
+}
+
 function setPrimary(personId, { adapter, channelId }) {
   const all = load();
   const p = all.find((x) => x.id === personId);
@@ -264,7 +288,7 @@ module.exports = {
   load, save, list, roster,
   add, update, remove,
   findById, findByName, findByCanonicalUserId, findByHandle,
-  linkHandle, unlinkHandle, setPrimary,
+  linkHandle, unlinkHandle, unlinkAdapterHandles, setPrimary,
   note, removeNote,
   setEntitySlug, resolveEntitySlug,
   owners, hasOwnerRecord, seedOwnerFromLegacy,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.14.4",
+  "version": "2.14.6",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {