@inetafrica/open-claudia 3.5.74 → 3.5.75

package/core/bot-profile.js

@@ -0,0 +1,228 @@
+// What kind of bot this is, from Central (plan v2 "personal bots act for their
+// owner", 25 Oct).
+//
+// On start, and every 15 minutes, the bot asks Central with its own key
+// (GET /api/bots/me): personal or autonomous, its one owner, and the owner's
+// consent (the apps she ticked, the end date, renewDue a week before it ends).
+// The answer is kept on disk so a restart while Central is down still knows.
+//
+// A personal bot:
+//   • has exactly one owner, the person in Central. applyOwner() puts her id in
+//     KAZEE_OWNER_USER_ID, and access.js counts no other owner (no second-owner
+//     records). Admins look after the bot through Agent Space and Central.
+//   • never hands its own key to an app: core/app-pass.js trades it for a pass.
+//   • gets its own instructions (instructionsBlock).
+// An autonomous bot, or a bot whose Central has no bot:me yet, is unchanged.
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const http = require("http");
+const { URL } = require("url");
+
+const FILE_NAME = "bot-profile.json";
+const REFRESH_MS = 15 * 60 * 1000;
+
+let profile;
+let timer = null;
+
+function configModule() { return require("./config"); }
+
+function profileFile(dir) {
+  return path.join(dir || configModule().CONFIG_DIR, FILE_NAME);
+}
+
+function readProfile(dir) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(profileFile(dir), "utf-8"));
+    return raw && raw.bot ? raw : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function get() {
+  if (profile === undefined) profile = readProfile();
+  return profile;
+}
+
+function isPersonal() { return get()?.bot?.botKind === "personal"; }
+function ownerUserId() { return isPersonal() ? String(get()?.owner?.id || "") : ""; }
+function ownerName() { return isPersonal() ? String(get()?.owner?.name || "") : ""; }
+function ownerFirstName() { return ownerName().split(" ")[0] || "your owner"; }
+function consent() { return isPersonal() ? get()?.consent || null : null; }
+function consentApplications() {
+  const c = consent();
+  return c && c.live !== false ? (c.applications || []).map((a) => a.name).filter(Boolean) : [];
+}
+function renewDue() { return !!consent()?.renewDue; }
+
+// The apps whose back ends take a pass, so the owner can tick them (Central's
+// OWNER_PASS_APPLICATIONS). Central's list when bot:me sends one, else its
+// default; Chat is left out, the bot talks there as itself.
+const DEFAULT_PASS_APPLICATIONS = ["Ticket_Central", "kazee-crm", "agent-space-backend", "kazee-infrastructure", "kazee-spaces-backend"];
+function passApplications() {
+  if (!isPersonal()) return [];
+  const p = get();
+  const list = Array.isArray(p?.passApplications) && p.passApplications.length ? p.passApplications : DEFAULT_PASS_APPLICATIONS;
+  const chat = p?.chatApplications || [];
+  return list.filter((a) => a && !chat.includes(a));
+}
+
+// Read straight from disk with no config: config.js calls this while it loads,
+// so the owner is right before any adapter is built.
+function cachedPersonalOwnerId(dir) {
+  const p = readProfile(dir);
+  return p?.bot?.botKind === "personal" && p.owner?.id ? String(p.owner.id) : "";
+}
+
+// A personal bot's one owner replaces the configured Kazee owner.
+function applyOwner(config) {
+  const owner = ownerUserId();
+  if (owner && config) config.KAZEE_OWNER_USER_ID = owner;
+  return owner;
+}
+
+function centralUrl() {
+  const { config } = configModule();
+  return String(config.CENTRAL_URL || "https://central.inet.africa").replace(/\/$/, "");
+}
+
+function botToken() {
+  const { config } = configModule();
+  return config.KAZEE_BOT_TOKEN || process.env.KAZEE_BOT_TOKEN || "";
+}
+
+// One JSON request to Central. Resolves { status, body } for any HTTP answer;
+// rejects only when Central can't be reached.
+function centralRequest(method, urlPath, token, body, timeoutMs = 15000) {
+  return new Promise((resolve, reject) => {
+    const u = new URL(centralUrl() + urlPath);
+    const lib = u.protocol === "https:" ? https : http;
+    const data = body != null ? Buffer.from(JSON.stringify(body)) : null;
+    const headers = { Authorization: `Bearer ${token}`, Accept: "application/json" };
+    if (data) {
+      headers["Content-Type"] = "application/json";
+      headers["Content-Length"] = data.length;
+    }
+    const req = lib.request(
+      { method, hostname: u.hostname, port: u.port || (u.protocol === "https:" ? 443 : 80), path: u.pathname + (u.search || ""), headers },
+      (res) => {
+        let chunks = "";
+        res.on("data", (c) => { chunks += c; });
+        res.on("end", () => {
+          let parsed = {};
+          try { parsed = chunks ? JSON.parse(chunks) : {}; } catch (_) {}
+          resolve({ status: res.statusCode, body: parsed });
+        });
+      },
+    );
+    req.on("error", reject);
+    req.setTimeout(timeoutMs, () => req.destroy(new Error(`${method} ${urlPath} timeout`)));
+    if (data) req.write(data);
+    req.end();
+  });
+}
+
+// Ask Central what this bot is. An old Central (404) or a refusal leaves a
+// bot that was never told as it was; Central down keeps the last answer.
+async function refresh({ request = centralRequest } = {}) {
+  const token = botToken();
+  if (!token) return get();
+  let res;
+  try {
+    res = await request("GET", "/api/bots/me", token);
+  } catch (e) {
+    console.error("bot-profile: Central unreachable, keeping the last answer:", e.message);
+    return get();
+  }
+  if (res && res.status === 200 && res.body && res.body.bot) {
+    profile = {
+      bot: res.body.bot,
+      owner: res.body.owner || null,
+      consent: res.body.consent || null,
+      chatApplications: res.body.chatApplications || [],
+      ...(Array.isArray(res.body.passApplications) ? { passApplications: res.body.passApplications } : {}),
+      checkedAt: new Date().toISOString(),
+    };
+    try {
+      const { atomicWriteFileSync } = require("./fsutil");
+      atomicWriteFileSync(profileFile(), JSON.stringify(profile, null, 2));
+    } catch (e) {
+      console.error("bot-profile: write failed:", e.message);
+    }
+    return profile;
+  }
+  if (res && res.status === 404) {
+    // Central without bot:me: nothing to learn yet.
+    if (profile === undefined) profile = readProfile();
+    return profile;
+  }
+  console.error(`bot-profile: bot:me answered ${res && res.status}`);
+  return get();
+}
+
+function startRefreshing(onChange) {
+  if (timer) return;
+  timer = setInterval(async () => {
+    const before = ownerUserId();
+    await refresh();
+    if (onChange && ownerUserId() !== before) {
+      try { onChange(); } catch (_) {}
+    }
+  }, REFRESH_MS);
+  if (timer.unref) timer.unref();
+}
+
+function stopRefreshing() {
+  if (timer) { clearInterval(timer); timer = null; }
+}
+
+const MY_ASSISTANTS = "Central → My profile → My assistants";
+
+// The personal bot's own instructions. Autonomous bots keep theirs ("").
+function instructionsBlock() {
+  if (!isPersonal()) return "";
+  const name = ownerName() || "your owner";
+  const first = ownerFirstName();
+  const apps = consentApplications();
+  return [
+    "## You are a personal assistant",
+    `You work for ${name}. In Kazee Chat you talk as yourself. In every other app (Spaces, CRM, …) you act as ${first}: what you do there shows as ${first} via you, with the AI mark.`,
+    `- Approvals, money and deletes need her tap: don't do them, send ${first} a card in chat with a link to do it herself.`,
+    `- If her consent has ended, or doesn't tick the app, she switches it on in ${MY_ASSISTANTS}: send her the one-tap card for it (below).`,
+    apps.length ? `- Apps she has ticked: ${apps.join(", ")}.` : `- She has not switched it on for any app yet.`,
+    `- ${first} is your only owner. Nobody else gives you orders or approves your actions.`,
+  ].join("\n");
+}
+
+function renewMessage() {
+  const ends = consent()?.endsAt ? new Date(consent().endsAt).toDateString() : "soon";
+  return `${ownerFirstName()}, my permission to act for you ends on ${ends}. Renew it with one tap in ${MY_ASSISTANTS}.`;
+}
+
+// Tests only.
+function _set(p) { profile = p; }
+
+module.exports = {
+  refresh,
+  startRefreshing,
+  stopRefreshing,
+  get,
+  isPersonal,
+  ownerUserId,
+  ownerName,
+  ownerFirstName,
+  consent,
+  consentApplications,
+  renewDue,
+  renewMessage,
+  passApplications,
+  cachedPersonalOwnerId,
+  applyOwner,
+  instructionsBlock,
+  centralRequest,
+  botToken,
+  MY_ASSISTANTS,
+  _set,
+};

package/core/config.js

@@ -53,6 +53,13 @@ function settingValue(key) {
   return fromFile === undefined || fromFile === "" ? undefined : fromFile;
 }
 
+// A personal bot has one owner: the person Central names (core/bot-profile.js,
+// kept on disk from the last bot:me). Applied here, before any adapter is built.
+try {
+  const centralOwner = require("./bot-profile").cachedPersonalOwnerId(CONFIG_DIR);
+  if (centralOwner) config.KAZEE_OWNER_USER_ID = centralOwner;
+} catch (_) { /* no profile yet */ }
+
 function hasPathSeparator(value) {
   return value.includes("/") || value.includes("\\");
 }

package/core/connected-apps.js

@@ -96,14 +96,28 @@ function getJson(baseUrl, urlPath, token) {
 }
 
 // Ask central which apps this bot token is a member of. Returns [] on failure
-// (caller keeps the last-known list).
-async function fetchConnectedApps() {
+// (caller keeps the last-known list). A personal bot watches the apps its owner
+// ticked in her consent (core/bot-profile.js), as her: its own key only works
+// in Kazee Chat once its key limit is on.
+async function fetchConnectedApps({ request } = {}) {
+  const botProfile = require("./bot-profile");
+  if (botProfile.isPersonal()) {
+    return botProfile.consentApplications().map((name) => ({ id: name, name }));
+  }
   const token = botToken();
   if (!token) return [];
-  const res = await getJson(CENTRAL_URL, "/api/principal/applications", token);
+  const res = request
+    ? (await request("GET", "/api/principal/applications", token)).body
+    : await getJson(CENTRAL_URL, "/api/principal/applications", token);
   return Array.isArray(res?.applications) ? res.applications : [];
 }
 
+// The token to poll an app with: a pass for a personal bot (core/app-pass.js),
+// the bot's own key otherwise.
+async function tokenForApp(app, opts) {
+  return require("./app-pass").tokenFor(String(app?.name || ""), opts);
+}
+
 function registerConnector(connector) {
   if (!connector || !connector.appKey) throw new Error("connector needs an appKey");
   connectors.set(connector.appKey, connector);
@@ -141,7 +155,7 @@ async function pollApp(app) {
   const connector = connectorFor(app);
   if (!connector) { state.status = "no-connector"; return; }
   try {
-    const items = await connector.poll(app, botToken());
+    const items = await connector.poll(app, await tokenForApp(app));
     const added = recordItems(state, items || []);
     state.lastPollAt = now;
     state.status = "ok";
@@ -244,6 +258,7 @@ module.exports = {
   stopConnectedApps,
   registerConnector,
   fetchConnectedApps,
+  tokenForApp,
   snapshot,
   getAllInboxes,
   STORE_FILE,

package/core/handlers.js

@@ -642,7 +642,9 @@ register({
   handler: async (env) => {
     if (!ownerEnv(env)) return;
     const { mint, TTL_MS } = require("./web-otp");
-    const { token } = mint();
+    // The link names who asked, so a personal bot's dashboard knows it is
+    // her (core/access.js); an autonomous bot ignores it.
+    const { token } = mint({ userId: env.userId || "" });
     const url = `${dashboardBaseUrl()}/otp/${token}`;
     const mins = Math.round(TTL_MS / 60000);
     const lines = [`Web dashboard login (valid ${mins} min, single use):`, url];

package/core/identity.js

@@ -98,6 +98,20 @@ function isConfiguredOwnerChannel(transport, channelId) {
   // is the same configured Kazee owner id — recognise them on Spaces too, else
   // the owner's own comments are classed external (default-deny).
   if (t === "spaces") return !!cfg.config.KAZEE_OWNER_USER_ID && c === String(cfg.config.KAZEE_OWNER_USER_ID);
+  // A personal bot's dashboard and voice bridge are owner channels only when
+  // they name its one owner (Central's); see access.transportOwnerUserId.
+  if (t === "voice" || t === "web") {
+    let personal = false, owner = "";
+    try {
+      const botProfile = require("./bot-profile");
+      personal = botProfile.isPersonal();
+      owner = botProfile.ownerUserId();
+    } catch (e) {}
+    if (personal) {
+      if (!owner || c !== owner) return false;
+      return t === "web" || String(cfg.config.VOICE_OWNER_USER_ID || "") === owner;
+    }
+  }
   if (t === "voice") return c === String(cfg.config.VOICE_OWNER_USER_ID || "voice-owner");
   // Web dashboard chat: fixed single-owner channel gated by the dashboard
   // session, so its identity is operator-implied rather than env-declared.

package/core/loopback.js

@@ -108,6 +108,7 @@ const JSON_KINDS = new Set([
   "tool-gate",
   "say", "call-say", "call", "tts", "transcribe",
   "card-send", "card-update", "card-show", "decide-add", "decide-list", "decide-cancel",
+  "owner-setup",
 ]);
 
 // Who is calling, decided by the bot: the principal of a LIVE run whose
@@ -452,6 +453,26 @@ async function handleJson(req, res, url, kind) {
     return handleCardKind(res, kind, payload, { channelId, adapterId, adapter });
   }
 
+  // `open-claudia owner-setup` (core/owner-setup.js): the one-tap card that
+  // lets a personal bot's owner switch it on or renew it. It always goes to
+  // HER direct chat, never this room; the bot decides what it says from its
+  // own profile. A run that is not hers sends each card at most once a day.
+  if (kind === "owner-setup") {
+    const caller = callerOf(payload);
+    if (!caller.attributed) return reply(res, 403, { error: "owner-setup can only be used from a live, attributed run" });
+    const ownerSetup = require("./owner-setup");
+    const planned = ownerSetup.plan({ apps: Array.isArray(payload.apps) ? payload.apps.map(String) : [], renew: payload.renew === true });
+    if (planned.refused) return reply(res, 400, { error: planned.refused });
+    if (planned.nothing) return reply(res, 200, { ok: true, sent: null, nothing: planned.nothing });
+    try {
+      const sent = await ownerSetup.tellOwnerAsked(planned, { owner: caller.owner === true });
+      if (!sent) return reply(res, 502, { error: "could not reach the owner's direct chat in Kazee" });
+      return reply(res, 200, { ok: true, sent, title: planned.card ? planned.card.title : null });
+    } catch (e) {
+      return reply(res, 502, { error: e.message });
+    }
+  }
+
   if (kind === "call-say") {
     try {
       const result = await require("./call-speech").speak({ ...payload, channelId, userId, adapter: adapterId });

package/core/owner-setup.js

@@ -0,0 +1,216 @@
+// The owner switches a personal bot on (or renews it) with one tap (SEC-28,
+// Sumeet 30 Oct 2026).
+//
+// Instead of telling her where the page is, the bot sends its owner a Kazee
+// Chat card with one link button that opens Central straight at the form; she
+// only taps Confirm or Renew. Used when an app refuses a pass because she has
+// not switched the bot on there (core/app-pass.js), for the daily renew notice
+// a week before the consent ends, and for `open-claudia owner-setup`.
+//
+// The card is a "report" card (no questions) with a `link` block, at most 2 per
+// card (chat-central, 30 Oct). If the card can't be sent the owner gets the old
+// text, with the link.
+//
+// The bot can never switch itself on: the link only opens the form, and only
+// the owner, signed in to Central, can confirm it.
+
+const botProfile = require("./bot-profile");
+const appPass = require("./app-pass");
+
+const CENTRAL_WEB = "https://central.kazee.africa";
+const ASSISTANTS_PATH = "/settings/assistants";
+const LINK_LABEL_MAX = 40;
+const CONSENT_DAYS = 90;
+const SEND_EVERY_MS = 24 * 60 * 60 * 1000;
+
+// The refusals the owner fixes herself by switching the bot on for the app.
+const SWITCH_ON_REASONS = new Set(["consent-none", "consent-off", "consent-ended", "app-not-ticked"]);
+
+const sentAt = new Map(); // card key -> last sent at (non-owner callers only)
+let lastRenewDay = "";
+
+function switchOnUrl(botId, apps) {
+  const list = apps.map((a) => encodeURIComponent(a)).join(",");
+  return `${CENTRAL_WEB}${ASSISTANTS_PATH}?bot=${encodeURIComponent(botId)}&do=switch-on&apps=${list}`;
+}
+
+function renewUrl(botId) {
+  return `${CENTRAL_WEB}${ASSISTANTS_PATH}?bot=${encodeURIComponent(botId)}&do=renew`;
+}
+
+// "Tickets", "Tickets and CRM", "Tickets, CRM and Spaces".
+function listWords(words) {
+  if (words.length <= 1) return words.join("");
+  return `${words.slice(0, -1).join(", ")} and ${words[words.length - 1]}`;
+}
+
+function dateWords(when) {
+  const d = new Date(when);
+  if (!Number.isFinite(d.getTime())) return "soon";
+  return d.toLocaleDateString("en-GB", { weekday: "long", day: "numeric", month: "long", year: "numeric" });
+}
+
+// The bot as the owner knows it: its own name (BOT_NAME, else its hostname),
+// else Central's name for it; and Central's id.
+function botForCard() {
+  let name = "";
+  try { name = String(require("./config").settingValue("BOT_NAME") || "").trim(); } catch (_) {}
+  // Else the pod's name from its public hostname (as the dashboard does).
+  if (!name) {
+    try {
+      const url = String(require("./config").settingValue("WEB_PUBLIC_URL") || "").trim();
+      if (url) name = new URL(url).hostname.split(".")[0] || "";
+    } catch (_) {}
+  }
+  if (!name) name = botProfile.get()?.bot?.name || "your assistant";
+  return { id: String(botProfile.get()?.bot?.id || ""), name: name.charAt(0).toUpperCase() + name.slice(1) };
+}
+
+function linkBlock(label, url) {
+  return { type: "link", label: String(label).slice(0, LINK_LABEL_MAX), url };
+}
+
+function buildSwitchOnCard({ bot, apps }) {
+  const labels = apps.map(appPass.appLabel);
+  const where = labels.length <= 2 ? listWords(labels) : "your apps";
+  return {
+    v: 1,
+    kind: "report",
+    title: `Let ${bot.name} work in ${where} for you`,
+    body: `${bot.name} can then work in ${listWords(labels)} as you, with the AI mark, for ${CONSENT_DAYS} days, and you can switch it off any time.`,
+    blocks: [linkBlock("Switch me on", switchOnUrl(bot.id, apps))],
+  };
+}
+
+function buildRenewCard({ bot, endsAt }) {
+  return {
+    v: 1,
+    kind: "report",
+    title: `Keep ${bot.name} working for you`,
+    body: `${bot.name}'s permission to act for you ends on ${dateWords(endsAt)}; renew it for another ${CONSENT_DAYS} days.`,
+    blocks: [linkBlock("Renew", renewUrl(bot.id))],
+  };
+}
+
+// The text an old app (or a failed card) shows: the words plus the link.
+function withLink(text, card) {
+  const url = card?.blocks?.find((b) => b.type === "link")?.url;
+  return url ? `${text}\n${url}` : text;
+}
+
+function switchOnText(apps) {
+  const words = listWords(apps.map(appPass.appLabel));
+  return `${botProfile.ownerFirstName()}, to let me work in ${words} for you: open ${botProfile.MY_ASSISTANTS}, tap Let it act for me and tick ${words}.`;
+}
+
+// A refused pass: the switch-on card for that app, or (another reason, like
+// the owner's own account lacking access) just the text.
+function forRefusal(err, text) {
+  const message = text || err?.ownerMessage || "";
+  if (!err || !SWITCH_ON_REASONS.has(err.reason) || !botProfile.isPersonal()) return { text: message };
+  const card = buildSwitchOnCard({ bot: botForCard(), apps: [err.applicationName] });
+  return { card, text: withLink(message, card), key: `switch-on:${err.applicationName}` };
+}
+
+function forRenew() {
+  const card = buildRenewCard({ bot: botForCard(), endsAt: botProfile.consent()?.endsAt });
+  return { card, text: withLink(botProfile.renewMessage(), card), key: "renew" };
+}
+
+// What `open-claudia owner-setup` sends. `apps` names Central apps (or the
+// labels the owner uses: "Tickets"); none means the pass-ready apps the live
+// consent doesn't tick yet. Answers { card, text } or { nothing: "<line>" }.
+function plan({ apps = [], renew = false } = {}) {
+  if (!botProfile.isPersonal()) {
+    return { refused: "Only a personal bot is switched on by its owner; this bot works with its own key." };
+  }
+  const consent = botProfile.consent();
+  if (renew && consent?.endsAt) return forRenew();
+  const wanted = apps.map(appName).filter(Boolean);
+  const on = botProfile.consentApplications();
+  const missing = wanted.length ? wanted : botProfile.passApplications().filter((a) => !on.includes(a));
+  if (missing.length) {
+    const card = buildSwitchOnCard({ bot: botForCard(), apps: missing });
+    return { card, text: withLink(switchOnText(missing), card), key: `switch-on:${missing.join(",")}` };
+  }
+  if (botProfile.renewDue()) return forRenew();
+  const until = consent?.endsAt ? `, until ${dateWords(consent.endsAt)}` : "";
+  return { nothing: `Already switched on for every app I can work in for ${botProfile.ownerFirstName()} (${listWords(on.map(appPass.appLabel))})${until}. Nothing sent.` };
+}
+
+// "Tickets" -> "Ticket_Central"; a Central name stays as it is.
+function appName(raw) {
+  const s = String(raw || "").trim();
+  if (!s) return "";
+  const known = [...new Set([...botProfile.passApplications(), ...botProfile.consentApplications()])];
+  return known.find((n) => n === s)
+    || known.find((n) => appPass.appLabel(n).toLowerCase() === s.toLowerCase())
+    || s;
+}
+
+function kazeeAdapter() {
+  try { return require("./adapter-registry").getAdapters().find((a) => a.type === "kazee") || null; }
+  catch (_) { return null; }
+}
+
+// Send { card, text } to the owner's direct Kazee chat: the card, else the
+// text. Resolves "card", "text" or null (no Kazee, no owner, nothing sent).
+async function tellOwner({ card, text }, { adapter = kazeeAdapter() } = {}) {
+  const ownerId = botProfile.ownerUserId();
+  if (!ownerId || !adapter || typeof adapter.directChatFor !== "function") return null;
+  const chatId = await adapter.directChatFor(ownerId);
+  if (!chatId) return null;
+  if (card && typeof adapter.sendCard === "function") {
+    try {
+      if (await adapter.sendCard(chatId, card, { content: text })) return "card";
+      console.error("owner-setup: Kazee Chat returned no message id for the card; sending the text");
+    } catch (e) {
+      console.error("owner-setup: card not sent, sending the text:", e.message);
+    }
+  }
+  if (!text) return null;
+  await adapter.send(chatId, text);
+  return "text";
+}
+
+// A run that is not the owner's asks at most once a day per card, so nobody
+// else can fill her chat with cards.
+async function tellOwnerAsked(sending, { owner = false, now = Date.now(), adapter } = {}) {
+  const key = sending.key || sending.text;
+  if (!owner && now - (sentAt.get(key) || 0) < SEND_EVERY_MS) return "already-sent";
+  sentAt.set(key, now);
+  return tellOwner(sending, adapter ? { adapter } : undefined);
+}
+
+// The renew card, once a day while Central says renewDue.
+async function maybeSendRenew({ now = new Date(), adapter } = {}) {
+  const today = now.toISOString().slice(0, 10);
+  if (!botProfile.renewDue() || lastRenewDay === today) return null;
+  lastRenewDay = today;
+  try { return await tellOwner(forRenew(), adapter ? { adapter } : undefined); }
+  catch (e) { console.error("renew notice failed:", e.message); return null; }
+}
+
+// Tests only.
+function reset() {
+  sentAt.clear();
+  lastRenewDay = "";
+}
+
+module.exports = {
+  buildSwitchOnCard,
+  buildRenewCard,
+  switchOnUrl,
+  renewUrl,
+  forRefusal,
+  forRenew,
+  plan,
+  tellOwner,
+  tellOwnerAsked,
+  maybeSendRenew,
+  botForCard,
+  reset,
+  SWITCH_ON_REASONS,
+  LINK_LABEL_MAX,
+  CENTRAL_WEB,
+};

package/core/system-prompt.js

@@ -261,6 +261,24 @@ function buildBrowserAppBlock() {
 Kazee Chat Browser app: people in a direct chat with you can watch this browser live, take it over, and teach you a task (Teach me). When you need a person in the browser (a login, a captcha, a one-time code, a judgement call), send a card in their direct chat with an Open Browser button, say what you need, then wait: you are woken in that chat when they hand it back. For example \`open-claudia card send '{"v":1,"kind":"report","title":"I need you in the browser","body":"<what you need and why>","open":{"app":"browser","label":"Open Browser"}}'\`. While someone drives, your agent-browser commands other than get, snapshot and screenshot are refused. Never ask for passwords in chat.`;
 }
 
+// A personal bot's own instructions (core/bot-profile.js): it works for one
+// person, acts as her in apps, and asks her first for approvals, money and
+// deletes. Stable for the bot, so it lives in the cached core. Autonomous
+// bots keep their current instructions ("").
+// A personal bot also learns how its owner switches it on: one tap on a card,
+// never a page to find (core/owner-setup.js).
+function buildBotKindBlock() {
+  try {
+    const block = require("./bot-profile").instructionsBlock();
+    if (!block) return "";
+    return [
+      block,
+      "- When your owner asks how to let you work for them, or an app refuses you because you're not switched on there, run `open-claudia owner-setup` (add `--apps <app>` when one app is needed; `--renew` to renew) so they get a one-tap card in Kazee Chat.",
+      "- Never ask them to find the page by hand. You can never switch yourself on: only they can confirm it.",
+    ].join("\n");
+  } catch (e) { return ""; }
+}
+
 function buildCoreInstructionsUncached() {
   const soul = loadSoul();
   // Gate on actual TTS capability, not local Whisper: hosted pods hear and
@@ -271,6 +289,7 @@ function buildCoreInstructionsUncached() {
 ${soul}
 ${buildPersonaBlock()}
 ${buildLessonsBlock()}
+${buildBotKindBlock()}
 ## Open Claudia runtime
 - Interface: chat through Open Claudia using the selected coding-agent provider.
 - Voice notes: ${hasVoice ? "enabled" : "disabled"}
@@ -1569,6 +1588,7 @@ const buildSystemPrompt = buildCoreInstructions;
 
 module.exports = {
   browserRuntimeNote,
+  buildBotKindBlock,
   liveCallCameraNote,
   voiceReplyGuidance,
   PromptConstructionError,

package/core/web-otp.js

@@ -19,26 +19,35 @@ function _save(list) {
   try { fs.writeFileSync(OTP_FILE, JSON.stringify(list), { mode: 0o600 }); } catch (e) {}
 }
 
-function mint(ttlMs = TTL_MS) {
+// `userId` names the person the link is for (the /dashboard command passes
+// the sender). Agent Space's SSO mint names nobody. A personal bot counts a
+// dashboard session as its owner only when it names her (core/access.js).
+function mint(opts = {}) {
+  const { ttlMs = TTL_MS, userId = "" } = typeof opts === "number" ? { ttlMs: opts } : (opts || {});
   const token = crypto.randomBytes(32).toString("hex");
   const expiresAt = Date.now() + ttlMs;
   const now = Date.now();
   const list = _load().filter((e) => e && e.expiresAt > now);
-  list.push({ token, expiresAt });
+  list.push(userId ? { token, expiresAt, userId: String(userId) } : { token, expiresAt });
   _save(list);
   return { token, expiresAt };
 }
 
-// Validate and burn (single use). Returns true only if the token was
-// present and unexpired; prunes expired entries either way.
-function consume(token) {
-  if (!token || typeof token !== "string") return false;
+// Validate and burn (single use). Returns the entry ({ userId? }) only if
+// the token was present and unexpired, else null; prunes expired entries
+// either way.
+function take(token) {
+  if (!token || typeof token !== "string") return null;
   const now = Date.now();
   const list = _load();
   const idx = list.findIndex((e) => e && e.token === token && e.expiresAt > now);
   const remaining = list.filter((e, i) => e && e.expiresAt > now && i !== idx);
   if (remaining.length !== list.length) _save(remaining);
-  return idx !== -1;
+  return idx !== -1 ? list[idx] : null;
+}
+
+function consume(token) {
+  return !!take(token);
 }
 
-module.exports = { mint, consume, OTP_FILE, TTL_MS };
+module.exports = { mint, take, consume, OTP_FILE, TTL_MS };