@inetafrica/open-claudia 2.14.4 → 2.14.5

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 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/handlers.js

@@ -1674,21 +1674,32 @@ register({
       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);
+      const transport = id.split(":")[0];
       // 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 kept = channels.filter((c) => c !== id && !c.startsWith(id + ":") && c !== transport);
       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 = "";
+      if (transport === "kazee") {
+        for (const k of ["KAZEE_URL", "KAZEE_BOT_TOKEN", "KAZEE_OWNER_USER_ID", "KAZEE_BOT_USER_ID"]) {
+          saveEnvKey(k, "");
+          config[k] = "";
+        }
       }
-      return send(`Removed channel: ${id}`);
+      // Complete the teardown: drop this transport's handles from every person
+      // record and its identity mappings. Both mutate through the in-memory
+      // stores, so disk and the running process stay consistent — otherwise a
+      // stale handle/link survives in memory and gets rewritten on the next
+      // add, which is exactly what made a re-add feel un-clean.
+      let unlinked = 0;
+      try { unlinked = require("./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 send(`Removed channel: ${id}${extra}`);
     }
 
     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.5",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {