@inetafrica/open-claudia 1.20.0 → 2.0.0

package/core/identity.js

@@ -0,0 +1,87 @@
+// Per-channel → canonical user mapping. The single source of truth for
+// "who is this message from" across Telegram, Kazee, and any future
+// transport. Default canonical is `<transport>:<channelId>`; the user
+// can override with /link <email-or-id> to merge state across channels.
+
+const fs = require("fs");
+const { IDENTITIES_FILE } = require("./config");
+
+function normalizeCanonicalUserId(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function channelKey(transport, channelId) {
+  return `${String(transport || "").trim().toLowerCase()}:${String(channelId || "").trim()}`;
+}
+
+function defaultCanonicalForChannel(transport, channelId) {
+  return channelKey(transport, channelId);
+}
+
+function loadIdentities() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(IDENTITIES_FILE, "utf-8"));
+    return {
+      channels: raw && typeof raw.channels === "object" ? raw.channels : {},
+      preferred: raw && typeof raw.preferred === "object" ? raw.preferred : {},
+    };
+  } catch (e) {
+    return { channels: {}, preferred: {} };
+  }
+}
+
+const identities = loadIdentities();
+
+function saveIdentities() {
+  try { fs.writeFileSync(IDENTITIES_FILE, JSON.stringify(identities, null, 2)); } catch (e) {}
+}
+
+function canonicalForChannel(transport, channelId) {
+  const key = channelKey(transport, channelId);
+  return normalizeCanonicalUserId(identities.channels[key]) || defaultCanonicalForChannel(transport, channelId);
+}
+
+function canonicalForTelegram(chatId) {
+  return canonicalForChannel("telegram", chatId);
+}
+
+function canonicalForStoredUserKey(key) {
+  const id = String(key);
+  if (id.includes(":") || id.includes("@")) return normalizeCanonicalUserId(id);
+  // Legacy keys without a transport prefix are Telegram chat ids.
+  return canonicalForTelegram(id);
+}
+
+// Set or update a channel→canonical link. Returns metadata so the caller
+// can run state migration via core/state.js (cyclic-import-safe pattern).
+function setIdentityMapping(transport, channelId, canonicalUserId) {
+  const key = channelKey(transport, channelId);
+  const userId = normalizeCanonicalUserId(canonicalUserId);
+  if (!userId) throw new Error("Canonical user id is required.");
+  const hadExplicitMapping = Object.prototype.hasOwnProperty.call(identities.channels, key);
+  const previousUserId = canonicalForChannel(transport, channelId);
+  const defaultUserId = defaultCanonicalForChannel(transport, channelId);
+  identities.channels[key] = userId;
+  identities.preferred[userId] = { transport: String(transport).toLowerCase(), channelId: String(channelId) };
+  saveIdentities();
+  const shouldMigrate = !hadExplicitMapping || previousUserId === defaultUserId;
+  return {
+    key,
+    previousUserId,
+    userId,
+    shouldMigrate,
+    migrated: shouldMigrate && previousUserId !== userId,
+  };
+}
+
+module.exports = {
+  identities,
+  normalizeCanonicalUserId,
+  channelKey,
+  defaultCanonicalForChannel,
+  canonicalForChannel,
+  canonicalForTelegram,
+  canonicalForStoredUserKey,
+  setIdentityMapping,
+  saveIdentities,
+};

package/core/io.js

@@ -0,0 +1,59 @@
+// Channel-agnostic IO. Every send/edit/delete in core code goes through
+// here so that the right adapter is invoked for the in-flight message
+// without each handler having to know about transports.
+
+const { currentAdapter, currentChannelId } = require("./context");
+
+async function send(text, opts = {}) {
+  const adapter = currentAdapter();
+  const channelId = opts.channelId || currentChannelId();
+  if (!adapter || !channelId) {
+    console.error("send() called outside chat context");
+    return null;
+  }
+  return adapter.send(channelId, text, opts);
+}
+
+async function editMessage(messageId, text, opts = {}) {
+  const adapter = currentAdapter();
+  const channelId = opts.channelId || currentChannelId();
+  if (!adapter || !channelId) return;
+  return adapter.edit(channelId, messageId, text, opts);
+}
+
+async function deleteMessage(messageId) {
+  const adapter = currentAdapter();
+  const channelId = currentChannelId();
+  if (!adapter || !channelId) return;
+  return adapter.delete(channelId, messageId);
+}
+
+async function sendVoice(oggPath) {
+  const adapter = currentAdapter();
+  const channelId = currentChannelId();
+  if (!adapter || !channelId) return false;
+  return adapter.sendVoice(channelId, oggPath);
+}
+
+async function sendFile(filePath, caption) {
+  const adapter = currentAdapter();
+  const channelId = currentChannelId();
+  if (!adapter || !channelId) return false;
+  return adapter.sendFile(channelId, filePath, caption);
+}
+
+async function typing() {
+  const adapter = currentAdapter();
+  const channelId = currentChannelId();
+  if (!adapter || !channelId) return;
+  return adapter.typing(channelId);
+}
+
+function splitMessage(text, maxLen = 4000) {
+  if (text.length <= maxLen) return [text];
+  const chunks = [];
+  while (text.length > 0) { chunks.push(text.slice(0, maxLen)); text = text.slice(maxLen); }
+  return chunks;
+}
+
+module.exports = { send, editMessage, deleteMessage, sendVoice, sendFile, typing, splitMessage };

package/core/kazee-probe.js

@@ -0,0 +1,48 @@
+// Standalone Kazee GET /me probe. Lives outside the adapter so setup.js
+// can use it before .env exists (channel-wizard, which is the other
+// consumer, imports it indirectly).
+
+const https = require("https");
+const http = require("http");
+const { URL } = require("url");
+
+function validateKazee({ url, token }) {
+  return new Promise((resolve) => {
+    let u;
+    try { u = new URL(url.replace(/\/$/, "") + "/me"); }
+    catch (e) { return resolve({ ok: false, error: `Bad URL: ${e.message}` }); }
+    const lib = u.protocol === "https:" ? https : http;
+    const req = lib.request({
+      method: "GET",
+      hostname: u.hostname,
+      port: u.port || (u.protocol === "https:" ? 443 : 80),
+      path: u.pathname + (u.search || ""),
+      headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+    }, (res) => {
+      let chunks = "";
+      res.on("data", (c) => { chunks += c; });
+      res.on("end", () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          try {
+            const body = chunks ? JSON.parse(chunks) : {};
+            const botUserId = body?.user?._id || body?.user?.id || body?._id || "";
+            resolve({ ok: true, botUserId });
+          } catch (e) {
+            resolve({ ok: true, botUserId: "" });
+          }
+        } else if (res.statusCode === 401 || res.statusCode === 403) {
+          resolve({ ok: false, error: "Token rejected (401/403). Check that it's a valid Kazee bot token." });
+        } else if (res.statusCode === 404) {
+          resolve({ ok: false, error: "GET /me returned 404. Check that the URL points at the Kazee bot API root." });
+        } else {
+          resolve({ ok: false, error: `GET /me → HTTP ${res.statusCode}` });
+        }
+      });
+    });
+    req.on("error", (e) => resolve({ ok: false, error: e.message }));
+    req.setTimeout(15000, () => req.destroy(new Error("Timed out after 15s")));
+    req.end();
+  });
+}
+
+module.exports = { validateKazee };

package/core/media.js

@@ -0,0 +1,39 @@
+// Voice ↔ text helpers. Transport-neutral: works off local file paths
+// produced by adapter.downloadMedia().
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const { WHISPER_CLI, WHISPER_MODEL, FFMPEG, TEMP_DIR } = require("./config");
+
+const TTS_CMD = process.platform === "darwin" ? "say" : null;
+
+function transcribeAudio(oggPath) {
+  if (!WHISPER_CLI || !FFMPEG) return null;
+  const wavPath = oggPath.replace(/\.[^.]+$/, ".wav");
+  execSync(`"${FFMPEG}" -i "${oggPath}" -ar 16000 -ac 1 -y "${wavPath}" 2>/dev/null`);
+  const output = execSync(`"${WHISPER_CLI}" -m "${WHISPER_MODEL}" --no-timestamps -f "${wavPath}" 2>/dev/null`, { encoding: "utf-8" });
+  try { fs.unlinkSync(wavPath); } catch (e) {}
+  return output.split("\n")
+    .filter((l) => l.trim() && !l.startsWith("whisper_") && !l.startsWith("ggml_") && !l.startsWith("load_"))
+    .join(" ").trim();
+}
+
+function textToVoice(text) {
+  if (!TTS_CMD || !FFMPEG) return null;
+  try {
+    const clean = text.replace(/[*_`#>\[\]()]/g, "").replace(/\n{2,}/g, ". ").replace(/\n/g, " ").trim();
+    if (!clean) return null;
+    const aiffPath = path.join(TEMP_DIR, `tts-${Date.now()}.aiff`);
+    const oggPath = aiffPath.replace(".aiff", ".ogg");
+    execSync(`${TTS_CMD} ${JSON.stringify(clean)} -o "${aiffPath}"`, { timeout: 30000 });
+    execSync(`"${FFMPEG}" -i "${aiffPath}" -c:a libopus -y "${oggPath}" 2>/dev/null`, { timeout: 30000 });
+    try { fs.unlinkSync(aiffPath); } catch (e) {}
+    return oggPath;
+  } catch (e) {
+    console.error("TTS error:", e.message);
+    return null;
+  }
+}
+
+module.exports = { transcribeAudio, textToVoice, TTS_CMD };

package/core/onboarding.js

@@ -0,0 +1,97 @@
+// First-run flow. Owner-only in practice — once ONBOARDED=true is
+// written to .env, the gate stays closed for everyone else.
+
+const fs = require("fs");
+const { config, saveEnvKey, SOUL_FILE } = require("./config");
+const { currentState } = require("./state");
+const { send } = require("./io");
+
+function isOnboarded() {
+  return config.ONBOARDED === "true";
+}
+
+async function startOnboarding() {
+  const state = currentState();
+  state.onboardingStep = "name";
+  state.onboardingData = {};
+  await send("Welcome! Let's set me up.\n\nWhat should I call you?");
+}
+
+async function handleOnboarding(msg) {
+  const state = currentState();
+  const text = msg.text;
+  if (state.onboardingStep === "name") {
+    state.onboardingData.name = text;
+    state.onboardingStep = "role";
+    await send(`Nice to meet you, ${text}!\n\nWhat's your role? (e.g., "full-stack developer", "startup founder", "student")`);
+    return true;
+  }
+  if (state.onboardingStep === "role") {
+    state.onboardingData.role = text;
+    state.onboardingStep = "style";
+    await send("How should I communicate?\n\nPick a style:", {
+      keyboard: {
+        inline_keyboard: [
+          [
+            { text: "Concise & technical", callback_data: "ob:concise" },
+            { text: "Detailed & educational", callback_data: "ob:detailed" },
+          ],
+          [
+            { text: "Casual & friendly", callback_data: "ob:casual" },
+            { text: "Minimal (just code)", callback_data: "ob:minimal" },
+          ],
+        ],
+      },
+    });
+    return true;
+  }
+  return false;
+}
+
+function finishOnboarding(style) {
+  const state = currentState();
+  state.onboardingData.style = style;
+  state.onboardingStep = null;
+  const data = state.onboardingData;
+
+  const styleDescriptions = {
+    concise: "Direct, concise, technical. No fluff. Lead with the answer.",
+    detailed: "Thorough and educational. Explain the why, not just the what.",
+    casual: "Casual and friendly. Like chatting with a smart friend who codes.",
+    minimal: "Minimal output. Just code and brief explanations. No chatter.",
+  };
+
+  const soul = `# Soul
+
+You are ${data.name}'s personal AI coding assistant, running 24/7 across chat channels.
+
+## Identity
+- Tone: ${styleDescriptions[style]}
+- Platform: chat (mobile-first, keep messages short)
+
+## About ${data.name}
+- Role: ${data.role}
+
+## Working Style
+- Prefer action over discussion. Do the thing, then explain.
+- Send files for long output instead of text walls.
+- Proactively flag issues and suggest improvements.
+
+## Capabilities
+- Write, edit, and refactor code across all projects
+- Run commands, tests, builds
+- Send files, images, code snippets directly via chat
+- Run scheduled checks (cron jobs) and report results
+- Store and use credentials from the encrypted vault
+`;
+
+  fs.writeFileSync(SOUL_FILE, soul);
+  saveEnvKey("ONBOARDED", "true");
+  config.ONBOARDED = "true";
+
+  send(`All set, ${data.name}! I'm configured and ready.\n\nTap /session to pick a project and start working.`, {
+    keyboard: { inline_keyboard: [[{ text: "Pick a project", callback_data: "show:projects" }]] },
+  });
+}
+
+module.exports = { isOnboarded, startOnboarding, handleOnboarding, finishOnboarding };

package/core/process-tree.js

@@ -0,0 +1,40 @@
+// Background tools (e.g. Bash run_in_background, /stop on a dev server)
+// often spawn into their own session/group, so a single PGID kill on the
+// Claude CLI doesn't reach them. We walk the descendant tree explicitly
+// and signal each PID. Without this, runaway poll-loops survive
+// indefinitely after the parent CLI is SIGTERMed.
+
+const { execSync } = require("child_process");
+
+function descendantPids(rootPid) {
+  const seen = new Set();
+  const queue = [Number(rootPid)];
+  while (queue.length) {
+    const pid = queue.shift();
+    if (!pid || seen.has(pid)) continue;
+    seen.add(pid);
+    try {
+      const out = execSync(`pgrep -P ${pid}`, { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+      for (const line of out.split("\n")) {
+        const child = Number(line.trim());
+        if (child) queue.push(child);
+      }
+    } catch (e) {
+      // pgrep exits 1 when no children — ignore.
+    }
+  }
+  seen.delete(Number(rootPid));
+  return [...seen];
+}
+
+function killProcessTree(rootPid, signal = "SIGTERM") {
+  if (!rootPid) return;
+  const descendants = descendantPids(rootPid);
+  try { process.kill(-rootPid, signal); } catch (e) {}
+  try { process.kill(rootPid, signal); } catch (e) {}
+  for (const pid of descendants) {
+    try { process.kill(pid, signal); } catch (e) {}
+  }
+}
+
+module.exports = { descendantPids, killProcessTree };

package/core/projects.js

@@ -0,0 +1,43 @@
+// Workspace project utilities. Reads filesystem; no IO dependencies.
+
+const fs = require("fs");
+const path = require("path");
+const { WORKSPACE } = require("./config");
+
+function listProjects() {
+  try {
+    return fs.readdirSync(WORKSPACE, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name)
+      .filter((n) => !n.startsWith("."));
+  } catch (e) { return []; }
+}
+
+function findProject(query) {
+  const projects = listProjects();
+  const q = query.toLowerCase();
+  const exact = projects.find((p) => p.toLowerCase() === q);
+  if (exact) return exact;
+  const startsWith = projects.filter((p) => p.toLowerCase().startsWith(q));
+  if (startsWith.length === 1) return startsWith[0];
+  const contains = projects.filter((p) => p.toLowerCase().includes(q));
+  if (contains.length === 1) return contains[0];
+  return contains.length > 0 ? contains : null;
+}
+
+function projectKeyboard() {
+  const projects = listProjects();
+  const rows = [[{ text: "\u{1F4C1} Workspace (root)", callback_data: "s:__workspace__" }]];
+  for (let i = 0; i < projects.length; i += 2) {
+    const row = [{ text: projects[i], callback_data: `s:${projects[i]}` }];
+    if (projects[i + 1]) row.push({ text: projects[i + 1], callback_data: `s:${projects[i + 1]}` });
+    rows.push(row);
+  }
+  return { inline_keyboard: rows };
+}
+
+function workspacePath(name) {
+  return name === "__workspace__" ? WORKSPACE : path.join(WORKSPACE, name);
+}
+
+module.exports = { listProjects, findProject, projectKeyboard, workspacePath };

package/core/redact.js

@@ -0,0 +1,26 @@
+// Secret-redaction + terminal-control stripping. Used everywhere we ship
+// CLI output (stderr, stdout, transcripts) back to a chat surface.
+
+function redactSensitive(value) {
+  return String(value || "")
+    .replace(/sk-ant-[A-Za-z0-9._-]+/g, "[REDACTED_TOKEN]")
+    .replace(/sk-proj-[A-Za-z0-9._-]+/g, "[REDACTED_OPENAI_KEY]")
+    .replace(/sk-[A-Za-z0-9._-]{20,}/g, "[REDACTED_OPENAI_KEY]")
+    .replace(/(Bearer\s+)[A-Za-z0-9._=-]+/gi, "$1[REDACTED_TOKEN]")
+    .replace(/(CLAUDE_CODE_OAUTH_TOKEN\s*=\s*)\S+/gi, "$1[REDACTED_TOKEN]")
+    .replace(/(OPENAI_API_KEY\s*=\s*)\S+/gi, "$1[REDACTED_OPENAI_KEY]")
+    .replace(/([?&](?:token|access_token|refresh_token|api_key)=)[^\s&]+/gi, "$1[REDACTED]");
+}
+
+function stripTerminalControls(value) {
+  return String(value || "")
+    .replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, "")
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+}
+
+function extractUrls(text) {
+  return [...stripTerminalControls(text).matchAll(/https?:\/\/[^\s)]+/g)].map((m) => m[0]);
+}
+
+module.exports = { redactSensitive, stripTerminalControls, extractUrls };