@inetafrica/open-claudia 2.1.0 → 2.1.1

package/bin/auth.js

@@ -0,0 +1,62 @@
+// open-claudia auth <subcommand>
+// Owner-only view of the raw auth.json store and direct deauth. Use
+// `open-claudia people` for richer roster operations. This is the
+// low-level escape hatch for legacy entries that don't have a person
+// record yet.
+
+const { postJson } = require("./loopback-client");
+
+const HELP = `
+Raw authorization store.
+
+  open-claudia auth list
+  open-claudia auth revoke <chatId>
+
+Owner-only. Revoking also unlinks the chat from any matching person.
+Owner entries are protected — refuse to self-deauth.
+`;
+
+async function runList() {
+  try {
+    const res = await postJson("auth-list", {});
+    const authorized = res.authorized || [];
+    const pending = res.pending || [];
+    if (authorized.length === 0 && pending.length === 0) { console.log("No authorized or pending chats."); process.exit(0); }
+    if (authorized.length) {
+      console.log("Authorized:");
+      for (const a of authorized) {
+        const owner = a.isOwner ? " (owner)" : "";
+        const person = a.personName ? `  → ${a.personName}` : "  → (no person record)";
+        console.log(`  ${a.chatId}${owner}  ${a.name || a.username || ""}${person}`);
+      }
+    }
+    if (pending.length) {
+      console.log("\nPending:");
+      for (const p of pending) console.log(`  ${p.chatId}  ${p.name || p.username || ""}  (requested ${p.requestedAt})`);
+    }
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runRevoke(args) {
+  const chatId = args[0];
+  if (!chatId) { console.error("Usage: auth revoke <chatId>"); process.exit(2); }
+  try {
+    const res = await postJson("auth-revoke", { chatId });
+    console.log(`Revoked ${chatId}${res.personId ? ` (was linked to person ${res.personId})` : ""}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function run(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+  if (!sub || sub === "--help" || sub === "help") { console.log(HELP); process.exit(sub ? 0 : 2); }
+  switch (sub) {
+    case "list": case "ls": return runList();
+    case "revoke": case "rm": return runRevoke(rest);
+    default: console.error(`Unknown auth subcommand: ${sub}`); console.log(HELP); process.exit(2);
+  }
+}
+
+module.exports = { run, HELP };

package/bin/cli.js

@@ -188,11 +188,17 @@ switch (command) {
     break;
   }
 
-  case "auth":
-    // Pass through to setup.js auth mode
+  case "auth": {
+    const sub = args[1];
+    if (["list", "ls", "revoke", "rm"].includes(sub)) {
+      require("./auth").run(args.slice(1));
+      break;
+    }
+    // Legacy: open-claudia auth (no subcommand) → setup.js auth mode
     process.argv = [process.argv[0], process.argv[1], "--auth"];
     require(path.join(botDir, "setup.js"));
     break;
+  }
 
   case "stop": {
     const pids = findBotProcesses();
@@ -318,6 +324,7 @@ Background work (only inside an active bot-spawned task):
 Multi-user / cross-channel:
   open-claudia people list|show|add|note|link      Roster of known team members
   open-claudia intros list|approve|reject          Pending introductions from unknown chats
+  open-claudia auth list|revoke <chatId>           Raw authorization view + direct deauth
   open-claudia send-to --person "<name>" "<msg>"   Relay a message to another team member
   open-claudia recent --person "<name>" [--limit]  Read recent activity from another chat
 

package/core/access.js

@@ -134,6 +134,36 @@ function recordPendingAuthRequest({ chatId, name, username }) {
   return { status: "queued" };
 }
 
+// Remove a chatId from the legacy auth.json. Owners are never removed
+// this way to avoid self-locking; the caller has to handle owner
+// demotion explicitly. Returns { ok, reason }.
+function revokeChat(chatId) {
+  const id = String(chatId || "");
+  if (!id) return { ok: false, reason: "missing_id" };
+  const auth = loadAuth();
+  const before = auth.authorized.length;
+  auth.authorized = auth.authorized.filter((a) => {
+    if (String(a.chatId) !== id) return true;
+    if (a.isOwner === true) return true;
+    return false;
+  });
+  auth.pending = auth.pending.filter((p) => String(p.chatId) !== id);
+  if (auth.authorized.length === before) {
+    if (auth.pending.length === 0) return { ok: false, reason: "not_found" };
+  }
+  saveAuth(auth);
+  updateAuthorizedChatEnv(auth);
+  return { ok: true };
+}
+
+function listAuthorizedRaw() {
+  const auth = loadAuth();
+  return {
+    authorized: auth.authorized.slice(),
+    pending: auth.pending.slice(),
+  };
+}
+
 function hasOwner() {
   if (CHAT_ID) return true;
   try {
@@ -173,4 +203,6 @@ module.exports = {
   updateAuthorizedChatEnv,
   hasOwner,
   bootstrapOwner,
+  revokeChat,
+  listAuthorizedRaw,
 };

package/core/audit.js

@@ -1,13 +1,30 @@
 // Append-only audit log for security-sensitive events: people CRUD,
 // intro decisions, cross-channel sends. One JSON record per line.
+// Auto-rotates when the file exceeds MAX_BYTES — the current file is
+// renamed to <name>.1 (overwriting any previous archive) and a fresh
+// file starts.
 
 const fs = require("fs");
 const { AUDIT_FILE } = require("./config");
 
+const MAX_BYTES = 2 * 1024 * 1024; // 2 MB; rotate at this size
+
+function rotateIfNeeded() {
+  try {
+    const stat = fs.statSync(AUDIT_FILE);
+    if (stat.size > MAX_BYTES) {
+      try { fs.renameSync(AUDIT_FILE, `${AUDIT_FILE}.1`); } catch (e) {}
+    }
+  } catch (e) {} // file may not exist yet
+}
+
 function log(kind, payload) {
   const entry = { at: new Date().toISOString(), kind, ...payload };
   const line = JSON.stringify(entry) + "\n";
-  try { fs.appendFileSync(AUDIT_FILE, line); } catch (e) {}
+  try {
+    rotateIfNeeded();
+    fs.appendFileSync(AUDIT_FILE, line);
+  } catch (e) {}
   return entry;
 }
 
@@ -20,4 +37,4 @@ function tail(n = 50) {
   } catch (e) { return []; }
 }
 
-module.exports = { log, tail };
+module.exports = { log, tail, MAX_BYTES };

package/core/handlers.js

@@ -121,6 +121,7 @@ register({
       "Session: /session /sessions /projects /continue /status /stop /end",
       "Settings: /model /effort /budget /plan /compact /worktree /mode",
       "Identity: /whoami /link",
+      "Team: /people /intros /auth (owner)",
       "Automation: /cron /vault /soul",
       "Claude auth: /auth_status /login /setup_token /use_oauth_token /clear_oauth_token",
       "Codex auth: /codex_auth_status /codex_login /codex_setup_token",
@@ -133,9 +134,41 @@ register({
 });
 
 register({
-  name: "auth", description: "Request access to this bot",
+  name: "auth", description: "Request access (or list/revoke as owner)", args: "[list | revoke <chatId>]",
   authRequired: false,
-  handler: async (env) => {
+  handler: async (env, { tail }) => {
+    if (tail) {
+      if (!authorized(env)) return;
+      if (!ownerEnv(env)) return send("Owner only — auth list/revoke are restricted.");
+      if (tail === "list") {
+        const raw = accessStore.listAuthorizedRaw();
+        const lines = ["Authorized chats:"];
+        for (const a of raw.authorized) {
+          const person = peopleStore.findByHandle("telegram", a.chatId) || peopleStore.findByHandle("kazee", a.chatId);
+          lines.push(`  ${a.chatId}${a.isOwner ? " (owner)" : ""}  ${a.name || a.username || ""}${person ? "  → " + person.name : "  → (no person)"}`);
+        }
+        if (raw.authorized.length === 0) lines.push("  (none)");
+        if (raw.pending.length > 0) {
+          lines.push("", "Pending:");
+          for (const p of raw.pending) lines.push(`  ${p.chatId}  ${p.name || p.username || ""}`);
+        }
+        return send(lines.join("\n"));
+      }
+      const revokeMatch = tail.match(/^revoke\s+(\S+)$/i);
+      if (revokeMatch) {
+        const chatId = revokeMatch[1];
+        const person = peopleStore.findByHandle("telegram", chatId) || peopleStore.findByHandle("kazee", chatId);
+        if (person && person.isOwner) return send("Refusing to revoke owner chat.");
+        if (person) {
+          const detected = (person.handles || []).find((h) => String(h.channelId) === String(chatId));
+          if (detected) peopleStore.unlinkHandle(person.id, { adapter: detected.adapter, channelId: detected.channelId });
+        }
+        const result = accessStore.revokeChat(chatId);
+        if (!result.ok) return send(`Revoke failed: ${result.reason}`);
+        return send(`Revoked ${chatId}${person ? ` (was ${person.name})` : ""}.`);
+      }
+      return send("Usage: /auth | /auth list | /auth revoke <chatId>");
+    }
     if (authorized(env)) {
       send("You're already authorized.");
       return;
@@ -1001,4 +1034,149 @@ register({
   },
 });
 
-module.exports.startSession = startSession;
+// ── Team (people / intros / auth) ─────────────────────────────────
+
+const peopleStore = require("./people");
+const introsStore = require("./intros");
+const introFlow = require("./intro-flow");
+const accessStore = require("./access");
+
+function formatPersonShort(p) {
+  const handles = (p.handles || []).map((h) => `${h.adapter}:${h.channelId}`).join(", ") || "(no handles)";
+  return `${p.name}${p.isOwner ? " (owner)" : ""} — ${handles}`;
+}
+
+register({
+  name: "people", description: "Manage team members", args: "[show|note|link|unlink|set-primary|add|remove ...]",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    if (!tail || tail === "list") {
+      const all = peopleStore.list();
+      if (all.length === 0) return send("No people yet.");
+      const lines = ["Team:"];
+      for (const p of all) lines.push(`  ${formatPersonShort(p)}`);
+      lines.push("", "More: /people show <name>, /people note <name> <text>");
+      return send(lines.join("\n"));
+    }
+    const showMatch = tail.match(/^show\s+(.+)$/i);
+    if (showMatch) {
+      const ref = showMatch[1].trim();
+      const person = peopleStore.findById(ref) || peopleStore.findByName(ref);
+      if (!person) return send(`Not found: ${ref}`);
+      const handles = (person.handles || []).map((h) => `  ${h.adapter}:${h.channelId}${person.primaryChannel && person.primaryChannel.adapter === h.adapter && String(person.primaryChannel.channelId) === String(h.channelId) ? " (primary)" : ""}`).join("\n");
+      const notes = (person.notes || []).slice(-5).map((n) => `  - [${(n.at || "").slice(0, 10)}] ${n.text}`).join("\n");
+      return send([
+        `${person.name}${person.isOwner ? " (owner)" : ""}  id=${person.id}`,
+        person.bio ? `Bio: ${person.bio}` : null,
+        "Handles:",
+        handles || "  (none)",
+        notes ? "Notes:" : null,
+        notes || null,
+      ].filter((x) => x !== null && x !== "").join("\n"));
+    }
+    const noteMatch = tail.match(/^note\s+(\S+)\s+(.+)$/i);
+    if (noteMatch) {
+      const person = peopleStore.findById(noteMatch[1]) || peopleStore.findByName(noteMatch[1]);
+      if (!person) return send(`Not found: ${noteMatch[1]}`);
+      const entry = peopleStore.note(person.id, noteMatch[2], { by: env.canonicalUserId || null });
+      return send(`Noted on ${person.name}: ${entry.text}`);
+    }
+    if (!ownerEnv(env)) return send("Owner only — add/link/unlink/set-primary/remove.");
+    const addMatch = tail.match(/^add\s+(.+)$/i);
+    if (addMatch) {
+      try {
+        const p = peopleStore.add({ name: addMatch[1].trim() });
+        return send(`Added ${p.name} (${p.id}). Link a channel with /people link ${p.name} <adapter> <channelId>.`);
+      } catch (e) { return send(`Failed: ${e.message}`); }
+    }
+    const linkMatch = tail.match(/^link\s+(\S+)\s+(\S+)\s+(\S+)$/i);
+    if (linkMatch) {
+      const person = peopleStore.findById(linkMatch[1]) || peopleStore.findByName(linkMatch[1]);
+      if (!person) return send(`Not found: ${linkMatch[1]}`);
+      try {
+        peopleStore.linkHandle(person.id, { adapter: linkMatch[2], channelId: linkMatch[3], approvedBy: env.canonicalUserId });
+        return send(`Linked ${linkMatch[2]}:${linkMatch[3]} → ${person.name}`);
+      } catch (e) { return send(`Failed: ${e.message}`); }
+    }
+    const unlinkMatch = tail.match(/^unlink\s+(\S+)\s+(\S+)\s+(\S+)$/i);
+    if (unlinkMatch) {
+      const person = peopleStore.findById(unlinkMatch[1]) || peopleStore.findByName(unlinkMatch[1]);
+      if (!person) return send(`Not found: ${unlinkMatch[1]}`);
+      const updated = peopleStore.unlinkHandle(person.id, { adapter: unlinkMatch[2], channelId: unlinkMatch[3] });
+      if (!updated) return send("Handle not found on that person.");
+      if (!person.isOwner) accessStore.revokeChat(unlinkMatch[3]);
+      return send(`Unlinked ${unlinkMatch[2]}:${unlinkMatch[3]} from ${person.name}.`);
+    }
+    const setPrimaryMatch = tail.match(/^set-primary\s+(\S+)\s+(\S+)\s+(\S+)$/i);
+    if (setPrimaryMatch) {
+      const person = peopleStore.findById(setPrimaryMatch[1]) || peopleStore.findByName(setPrimaryMatch[1]);
+      if (!person) return send(`Not found: ${setPrimaryMatch[1]}`);
+      try {
+        peopleStore.setPrimary(person.id, { adapter: setPrimaryMatch[2], channelId: setPrimaryMatch[3] });
+        return send(`Primary for ${person.name} → ${setPrimaryMatch[2]}:${setPrimaryMatch[3]}`);
+      } catch (e) { return send(`Failed: ${e.message}`); }
+    }
+    const removeMatch = tail.match(/^remove\s+(.+)$/i);
+    if (removeMatch) {
+      const person = peopleStore.findById(removeMatch[1]) || peopleStore.findByName(removeMatch[1]);
+      if (!person) return send(`Not found: ${removeMatch[1]}`);
+      if (person.isOwner) return send("Refusing to remove the owner.");
+      const handles = (person.handles || []).slice();
+      peopleStore.remove(person.id);
+      let revokedCount = 0;
+      for (const h of handles) { const r = accessStore.revokeChat(h.channelId); if (r.ok) revokedCount += 1; }
+      return send(`Removed ${person.name}. Deauthed ${revokedCount} chat${revokedCount === 1 ? "" : "s"}.`);
+    }
+    send("Usage: /people | /people show <name> | /people note <name> <text> | /people add|link|unlink|set-primary|remove ... (owner)");
+  },
+});
+
+register({
+  name: "intros", description: "Pending intros from unknown chats", args: "[approve|reject <id>]", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    if (!ownerEnv(env)) return send("Owner only.");
+    introsStore.sweep();
+    if (!tail || tail === "list") {
+      const pending = introsStore.listPending();
+      if (pending.length === 0) return send("No pending intros.");
+      const lines = ["Pending intros:"];
+      const buttons = [];
+      for (const i of pending) {
+        const claim = i.claim || {};
+        let claimLine = "no claim yet";
+        if (claim.kind === "existing") {
+          const p = peopleStore.findById(claim.personId);
+          claimLine = `claims to be ${p ? p.name : claim.personId}`;
+        } else if (claim.kind === "new") {
+          claimLine = `new: ${claim.name}${claim.bio ? " — " + claim.bio : ""}`;
+        }
+        lines.push(`  ${i.id}  ${i.adapter}:${i.channelId}  ${claimLine}`);
+        buttons.push([
+          { text: `Approve ${i.id.slice(-6)}`, callback_data: `intro:approve:${i.id}` },
+          { text: `Reject ${i.id.slice(-6)}`, callback_data: `intro:reject:${i.id}` },
+        ]);
+      }
+      return send(lines.join("\n"), buttons.length ? { keyboard: { inline_keyboard: buttons } } : undefined);
+    }
+    const approveMatch = tail.match(/^approve\s+(\S+)$/i);
+    if (approveMatch) {
+      const intro = introsStore.byId(approveMatch[1]);
+      if (!intro) return send(`No intro: ${approveMatch[1]}`);
+      try {
+        const result = await introFlow.applyApproval(intro, env.from?.name || env.canonicalUserId || "owner");
+        await introFlow.notifyIntroUser(intro, `You're in. Welcome${result.person ? ", " + result.person.name : ""}.`);
+        return send(`Approved. Person: ${result.person?.name || "?"}`);
+      } catch (e) { return send(`Failed: ${e.message}`); }
+    }
+    const rejectMatch = tail.match(/^reject\s+(\S+)(?:\s+(.+))?$/i);
+    if (rejectMatch) {
+      const intro = introsStore.byId(rejectMatch[1]);
+      if (!intro) return send(`No intro: ${rejectMatch[1]}`);
+      introsStore.reject(intro.id, env.from?.name || env.canonicalUserId || "owner", rejectMatch[2] || null);
+      await introFlow.notifyIntroUser(intro, "Your access request was denied.");
+      return send(`Rejected ${intro.id}.`);
+    }
+    send("Usage: /intros | /intros approve <id> | /intros reject <id> [reason]");
+  },
+});

package/core/loopback.js

@@ -23,6 +23,7 @@ const intros = require("./intros");
 const introFlow = require("./intro-flow");
 const relay = require("./relay");
 const audit = require("./audit");
+const access = require("./access");
 const fs2 = require("fs");
 const path2 = require("path");
 const { TRANSCRIPTS_DIR } = require("./config");
@@ -77,6 +78,7 @@ const JSON_KINDS = new Set([
   "people-remove", "people-set-primary",
   "intros-list", "intros-approve", "intros-reject",
   "relay-send", "recent-fetch", "audit-tail",
+  "auth-list", "auth-revoke",
 ]);
 
 function callerIsOwner(payload) {
@@ -305,8 +307,12 @@ async function handleJson(req, res, url, kind) {
     if (!person) return reply(res, 404, { error: "not found" });
     const updated = peopleStore.unlinkHandle(person.id, { adapter: payload.linkAdapter, channelId: payload.linkChannelId });
     if (!updated) return reply(res, 404, { error: "handle not found on person" });
-    audit.log("people.unlink", { by: payload.canonicalUserId, personId: person.id, adapter: payload.linkAdapter, channelId: payload.linkChannelId });
-    return reply(res, 200, { ok: true, person: updated });
+    let revoked = null;
+    if (!person.isOwner) {
+      revoked = access.revokeChat(payload.linkChannelId);
+    }
+    audit.log("people.unlink", { by: payload.canonicalUserId, personId: person.id, adapter: payload.linkAdapter, channelId: payload.linkChannelId, authRevoked: revoked });
+    return reply(res, 200, { ok: true, person: updated, authRevoked: !!(revoked && revoked.ok) });
   }
 
   if (kind === "people-set-primary") {
@@ -329,9 +335,42 @@ async function handleJson(req, res, url, kind) {
     const person = peopleStore.findById(ref) || peopleStore.findByName(ref);
     if (!person) return reply(res, 404, { error: "not found" });
     if (person.isOwner) return reply(res, 400, { error: "refusing to delete owner record" });
+    const handles = (person.handles || []).slice();
     peopleStore.remove(person.id);
-    audit.log("people.remove", { by: payload.canonicalUserId, personId: person.id, name: person.name });
-    return reply(res, 200, { ok: true, removed: person });
+    let revokedCount = 0;
+    for (const h of handles) {
+      const r = access.revokeChat(h.channelId);
+      if (r && r.ok) revokedCount += 1;
+    }
+    audit.log("people.remove", { by: payload.canonicalUserId, personId: person.id, name: person.name, revokedCount, handles });
+    return reply(res, 200, { ok: true, removed: person, revokedCount });
+  }
+
+  if (kind === "auth-list") {
+    if (!callerIsOwner(payload)) return reply(res, 403, { error: "owner only" });
+    const raw = access.listAuthorizedRaw();
+    const enriched = raw.authorized.map((a) => {
+      const person = peopleStore.findByHandle("telegram", a.chatId) || peopleStore.findByHandle("kazee", a.chatId);
+      return { ...a, personId: person?.id || null, personName: person?.name || null };
+    });
+    return reply(res, 200, { ok: true, authorized: enriched, pending: raw.pending });
+  }
+
+  if (kind === "auth-revoke") {
+    if (!callerIsOwner(payload)) return reply(res, 403, { error: "owner only" });
+    const chatId = payload.chatId;
+    if (!chatId) return reply(res, 400, { error: "missing chatId" });
+    const person = peopleStore.findByHandle("telegram", chatId) || peopleStore.findByHandle("kazee", chatId);
+    if (person && person.isOwner) return reply(res, 400, { error: "refusing to revoke owner chat" });
+    if (person) {
+      const detected = (person.handles || []).find((h) => String(h.channelId) === String(chatId));
+      if (detected) {
+        peopleStore.unlinkHandle(person.id, { adapter: detected.adapter, channelId: detected.channelId });
+      }
+    }
+    const result = access.revokeChat(chatId);
+    audit.log("auth.revoke", { by: payload.canonicalUserId, chatId, personId: person?.id || null, result });
+    return reply(res, result.ok ? 200 : 404, { ...result, personId: person?.id || null });
   }
 
   if (kind === "intros-list") {

package/core/system-prompt.js

@@ -11,6 +11,7 @@ const { vault } = require("./vault-store");
 const { transcriptPointerNote } = require("./transcripts");
 const tasksStore = require("./tasks");
 const people = require("./people");
+const commandsRegistry = require("./commands");
 
 function loadSoul() {
   try { return fs.readFileSync(SOUL_FILE, "utf-8"); }
@@ -63,6 +64,15 @@ function buildSystemPrompt() {
     }
   } catch (e) {}
 
+  let slashCommandsBlock = "";
+  try {
+    const cmds = commandsRegistry.publicCommands();
+    if (cmds.length > 0) {
+      const lines = cmds.map((c) => `- /${c.name}${c.args ? " " + c.args : ""}${c.description ? " — " + c.description : ""}`);
+      slashCommandsBlock = `\n## Slash commands available in chat\nThe user can type these directly. When a request maps to a slash command, prefer guiding them to use it rather than running open-claudia CLIs on their behalf. Owner-only commands are marked in their descriptions.\n\n${lines.join("\n")}\n`;
+    }
+  } catch (e) {}
+
   return `
 ${soul}
 
@@ -82,7 +92,7 @@ ${soul}
 - Received user files directory: ${FILES_DIR}
 
 ${transcriptPointerNote(state)}
-${currentSpeakerBlock}${teamBlock}${pendingTasksBlock}
+${currentSpeakerBlock}${teamBlock}${pendingTasksBlock}${slashCommandsBlock}
 ## Delivery
 Reply normally in your final answer. To send a file, image, or voice clip back to the current chat, run the bot CLI from inside this task — channel context is already in the env:
 - \`open-claudia send-file <path> [caption]\` — any document/binary
@@ -101,6 +111,8 @@ Wake-ups and crons (real schedulers, not hallucinations — use them instead of
 
 Persistent todo list with plans + subtasks (per channel; survives compaction and restart).
 
+Note: any \`<system-reminder>\` you see about "task tools" / TaskCreate / TaskUpdate is from the underlying Claude Code harness — that's a different, ephemeral todo system. Open Claudia work belongs in \`open-claudia task\` (the persistent, channel-scoped one). Don't double-track.
+
 Use a plan when work is likely to outlive a single turn — i.e. it may hit a compaction, a restart, or a scheduled wakeup before completing, or its progress is something the user will want to see between turns. The plan is a parent task whose children are the steps. As you work, mark each subtask in_progress when you begin and completed when done — this is how a resumed turn sees where you left off. If pending tasks already exist when you start a turn they will be shown under "## Pending tasks" above; check them first.
 
 Skip the plan for work that visibly completes within the current turn (e.g. running a few CLI commands in sequence and replying). A plan there is overhead the user has to read past.

package/package.json

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