@inetafrica/open-claudia 1.20.0 → 2.0.0

package/core/config.js

@@ -0,0 +1,197 @@
+// Loads .env, exposes paths, parses CHANNELS list, resolves optional CLIs.
+// Pure configuration — never touches runtime state.
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const CONFIG_DIR = require("../config-dir");
+const { truthy: configTruthy } = require("../project-transcripts");
+
+const BOT_DIR = path.resolve(__dirname, "..");
+const ENV_PATH = path.join(CONFIG_DIR, ".env");
+
+function loadEnv() {
+  if (!fs.existsSync(ENV_PATH)) {
+    console.error("No .env file found. Run: node setup.js");
+    process.exit(1);
+  }
+  const lines = fs.readFileSync(ENV_PATH, "utf-8").split("\n");
+  const env = {};
+  for (const line of lines) {
+    const idx = line.indexOf("=");
+    if (idx > 0) env[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+  return env;
+}
+
+function saveEnvKey(key, value) {
+  const content = fs.readFileSync(ENV_PATH, "utf-8");
+  const lines = content.split("\n");
+  let found = false;
+  const updated = lines.map((line) => {
+    if (line.startsWith(key + "=")) { found = true; return `${key}=${value}`; }
+    return line;
+  });
+  if (!found) updated.push(`${key}=${value}`);
+  fs.writeFileSync(ENV_PATH, updated.join("\n"));
+}
+
+const config = loadEnv();
+
+// Telegram (kept for backwards compat — channels list defaults to telegram)
+const TOKEN = config.TELEGRAM_BOT_TOKEN;
+const CHAT_IDS = (config.TELEGRAM_CHAT_ID || "").split(",").map((s) => s.trim()).filter(Boolean);
+const CHAT_ID = CHAT_IDS[0];
+
+const WORKSPACE = config.WORKSPACE;
+const CLAUDE_PATH = config.CLAUDE_PATH;
+const CURSOR_PATH = config.CURSOR_PATH || null;
+const CODEX_PATH = config.CODEX_PATH || null;
+const AUTO_COMPACT_TOKENS = parseInt(config.AUTO_COMPACT_TOKENS || process.env.AUTO_COMPACT_TOKENS || "280000", 10);
+const PROJECT_TRANSCRIPTS = configTruthy(config.PROJECT_TRANSCRIPTS || process.env.PROJECT_TRANSCRIPTS, true);
+const TRANSCRIPT_MAX_ENTRY_CHARS = parseInt(config.TRANSCRIPT_MAX_ENTRY_CHARS || process.env.TRANSCRIPT_MAX_ENTRY_CHARS || "12000", 10);
+const TRANSCRIPTS_DIR = config.TRANSCRIPTS_DIR || process.env.TRANSCRIPTS_DIR || path.join(CONFIG_DIR, "transcripts");
+const WHISPER_CLI = config.WHISPER_CLI || "";
+const WHISPER_MODEL = config.WHISPER_MODEL || "";
+const FFMPEG = config.FFMPEG || "";
+const SOUL_FILE = config.SOUL_FILE || path.join(CONFIG_DIR, "soul.md");
+const CRONS_FILE = config.CRONS_FILE || path.join(CONFIG_DIR, "crons.json");
+const VAULT_FILE = config.VAULT_FILE || path.join(CONFIG_DIR, "vault.enc");
+const AUTH_FILE = config.AUTH_FILE || path.join(CONFIG_DIR, "auth.json");
+const IDENTITIES_FILE = config.IDENTITIES_FILE || path.join(CONFIG_DIR, "identities.json");
+const STATE_FILE = path.join(CONFIG_DIR, "state.json");
+const SESSIONS_FILE = path.join(CONFIG_DIR, "sessions.json");
+
+const TEMP_DIR = path.join(CONFIG_DIR, "media");
+const FILES_DIR = path.join(CONFIG_DIR, "files");
+
+const MAX_FILE_SIZE = 50 * 1024 * 1024;
+const MAX_VOICE_SIZE = 10 * 1024 * 1024;
+const MAX_PROCESS_TIMEOUT = 360 * 60 * 1000;
+
+if (!WORKSPACE) { console.error("WORKSPACE not set"); process.exit(1); }
+if (!CLAUDE_PATH) { console.error("CLAUDE_PATH not set"); process.exit(1); }
+
+if (!fs.existsSync(WORKSPACE)) {
+  try {
+    fs.mkdirSync(WORKSPACE, { recursive: true });
+    console.log(`Created workspace: ${WORKSPACE}`);
+  } catch (e) {
+    console.error(`Failed to create workspace: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+if (!fs.existsSync(CLAUDE_PATH)) {
+  try {
+    execSync(`which "${CLAUDE_PATH}" 2>/dev/null || where "${CLAUDE_PATH}" 2>nul`, { encoding: "utf-8" });
+  } catch (e) {
+    console.error(`Claude CLI not found at: ${CLAUDE_PATH}`);
+    process.exit(1);
+  }
+}
+
+let resolvedCursorPath = CURSOR_PATH;
+if (!resolvedCursorPath) {
+  try { resolvedCursorPath = execSync("which agent 2>/dev/null", { encoding: "utf-8" }).trim() || null; }
+  catch (e) { resolvedCursorPath = null; }
+}
+if (resolvedCursorPath) console.log(`Cursor Agent CLI: ${resolvedCursorPath}`);
+
+let resolvedCodexPath = CODEX_PATH;
+if (!resolvedCodexPath) {
+  try { resolvedCodexPath = execSync("which codex 2>/dev/null", { encoding: "utf-8" }).trim() || null; }
+  catch (e) { resolvedCodexPath = null; }
+}
+if (resolvedCodexPath) console.log(`Codex CLI: ${resolvedCodexPath}`);
+
+if (!fs.existsSync(TEMP_DIR)) fs.mkdirSync(TEMP_DIR, { recursive: true });
+if (!fs.existsSync(FILES_DIR)) fs.mkdirSync(FILES_DIR, { recursive: true });
+
+const FULL_PATH = [
+  path.dirname(CLAUDE_PATH),
+  resolvedCursorPath ? path.dirname(resolvedCursorPath) : null,
+  resolvedCodexPath ? path.dirname(resolvedCodexPath) : null,
+  path.dirname(process.execPath),
+  FFMPEG ? path.dirname(FFMPEG) : null,
+  WHISPER_CLI ? path.dirname(WHISPER_CLI) : null,
+  ...(process.platform === "win32"
+    ? [process.env.APPDATA, process.env.LOCALAPPDATA].filter(Boolean).map((p) => path.join(p, "npm"))
+    : ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]
+  ),
+].filter(Boolean).join(path.delimiter);
+
+// Channels: declarative list of {id, type, opts}. Defaults to telegram for
+// backwards compat with installs predating CHANNELS.
+function loadChannels() {
+  const raw = (config.CHANNELS || "telegram").split(",").map((s) => s.trim()).filter(Boolean);
+  const channels = [];
+  for (const entry of raw) {
+    const [type, idOverride] = entry.split(":");
+    const id = idOverride || type;
+    if (type === "telegram") {
+      if (!TOKEN) {
+        console.error("CHANNELS includes telegram but TELEGRAM_BOT_TOKEN is unset — skipping.");
+        continue;
+      }
+      if (!CHAT_ID) {
+        console.warn("TELEGRAM_CHAT_ID is unset — first /auth will register the owner.");
+      }
+      channels.push({
+        id,
+        type: "telegram",
+        opts: { token: TOKEN, ownerChatId: CHAT_ID || "", chatIds: CHAT_IDS },
+      });
+    } else if (type === "kazee") {
+      const url = config.KAZEE_URL;
+      const token = config.KAZEE_BOT_TOKEN;
+      const ownerUserId = config.KAZEE_OWNER_USER_ID || "";
+      const botUserId = config.KAZEE_BOT_USER_ID || "";
+      if (!url || !token) {
+        console.error(`CHANNELS includes ${entry} but KAZEE_URL or KAZEE_BOT_TOKEN is unset — skipping.`);
+        continue;
+      }
+      if (!botUserId) {
+        console.warn(`CHANNELS includes ${entry} but KAZEE_BOT_USER_ID is unset — slash commands and self-echo filtering will not work.`);
+      }
+      channels.push({
+        id,
+        type: "kazee",
+        opts: { url, token, ownerUserId, botUserId },
+      });
+    } else {
+      console.error(`Unknown channel type: ${type} — skipping.`);
+    }
+  }
+  return channels;
+}
+
+function botSubprocessEnv() {
+  return { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() };
+}
+
+module.exports = {
+  config,
+  saveEnvKey,
+  loadChannels,
+  botSubprocessEnv,
+  BOT_DIR,
+  CONFIG_DIR,
+  TOKEN, CHAT_IDS, CHAT_ID,
+  WORKSPACE,
+  CLAUDE_PATH,
+  CURSOR_PATH,
+  CODEX_PATH,
+  resolvedCursorPath,
+  resolvedCodexPath,
+  AUTO_COMPACT_TOKENS,
+  PROJECT_TRANSCRIPTS,
+  TRANSCRIPT_MAX_ENTRY_CHARS,
+  TRANSCRIPTS_DIR,
+  WHISPER_CLI, WHISPER_MODEL, FFMPEG,
+  SOUL_FILE, CRONS_FILE, VAULT_FILE, AUTH_FILE, IDENTITIES_FILE,
+  STATE_FILE, SESSIONS_FILE,
+  TEMP_DIR, FILES_DIR,
+  MAX_FILE_SIZE, MAX_VOICE_SIZE, MAX_PROCESS_TIMEOUT,
+  FULL_PATH,
+};

package/core/context.js

@@ -0,0 +1,44 @@
+// Per-request async context: every inbound message runs inside one of
+// these scopes so that send()/edit()/etc. resolve to the right adapter
+// + channel without threading them through every function signature.
+
+const { AsyncLocalStorage } = require("node:async_hooks");
+
+const chatContext = new AsyncLocalStorage();
+
+function runInChat({ adapter, channelId, canonicalUserId, raw }, fn) {
+  return chatContext.run({ adapter, channelId, canonicalUserId, raw }, fn);
+}
+
+function currentStore() {
+  return chatContext.getStore() || null;
+}
+
+function currentAdapter() {
+  const s = currentStore();
+  return s ? s.adapter : null;
+}
+
+function currentChannelId() {
+  const s = currentStore();
+  return s ? s.channelId : null;
+}
+
+function currentCanonicalUserId() {
+  const s = currentStore();
+  return s ? s.canonicalUserId : null;
+}
+
+function currentRaw() {
+  const s = currentStore();
+  return s ? s.raw : null;
+}
+
+module.exports = {
+  chatContext,
+  runInChat,
+  currentAdapter,
+  currentChannelId,
+  currentCanonicalUserId,
+  currentRaw,
+};

package/core/cron.js

@@ -0,0 +1,77 @@
+// Cron loader and scheduler. Cron jobs fire from a timer (no inbound
+// message, so no chatContext) — we resolve the owner's preferred
+// channel from identities and bind the run to that adapter.
+
+const fs = require("fs");
+const path = require("path");
+const cron = require("node-cron");
+const { CRONS_FILE, WORKSPACE, CHAT_ID } = require("./config");
+const { runInChat } = require("./context");
+const { canonicalForTelegram, identities } = require("./identity");
+const { runClaudeSilent } = require("./runner");
+
+const activeCrons = new Map();
+let adaptersById = new Map();
+
+function setAdapters(adapters) {
+  adaptersById = new Map();
+  for (const a of adapters) adaptersById.set(a.type, a);
+}
+
+function loadCrons() {
+  try { return JSON.parse(fs.readFileSync(CRONS_FILE, "utf-8")); }
+  catch (e) { return []; }
+}
+
+function saveCrons(list) {
+  fs.writeFileSync(CRONS_FILE, JSON.stringify(list, null, 2));
+}
+
+function ownerDispatchTarget() {
+  // Prefer an explicit owner mapping; fall back to legacy Telegram CHAT_ID.
+  const ownerId = canonicalForTelegram(CHAT_ID || "");
+  const preferred = identities.preferred[ownerId];
+  if (preferred && preferred.transport && adaptersById.get(preferred.transport)) {
+    return {
+      adapter: adaptersById.get(preferred.transport),
+      channelId: String(preferred.channelId),
+      canonicalUserId: ownerId,
+    };
+  }
+  const tg = adaptersById.get("telegram");
+  if (tg && CHAT_ID) {
+    return { adapter: tg, channelId: String(CHAT_ID), canonicalUserId: ownerId };
+  }
+  return null;
+}
+
+function scheduleCron(c) {
+  const cwd = path.join(WORKSPACE, c.project);
+  if (activeCrons.has(c.id)) activeCrons.get(c.id).task.stop();
+  const task = cron.schedule(c.schedule, () => {
+    const target = ownerDispatchTarget();
+    if (!target) {
+      console.error(`Cron ${c.label}: no adapter available to deliver result`);
+      return;
+    }
+    runInChat(target, () => runClaudeSilent(c.prompt, cwd, c.label));
+  });
+  activeCrons.set(c.id, { task, config: c });
+}
+
+function initCrons() {
+  for (const c of loadCrons()) {
+    try { scheduleCron(c); }
+    catch (e) { console.error("Cron error:", e.message); }
+  }
+  console.log(`Loaded ${loadCrons().length} cron(s)`);
+}
+
+module.exports = {
+  activeCrons,
+  setAdapters,
+  loadCrons,
+  saveCrons,
+  scheduleCron,
+  initCrons,
+};

package/core/doctor.js

@@ -0,0 +1,126 @@
+// /doctor and /requirements helpers — sanity-check CLIs, auth, and disk
+// before the user spends time on a task that's going to fail anyway.
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const {
+  CLAUDE_PATH, CURSOR_PATH, CODEX_PATH, resolvedCursorPath, resolvedCodexPath,
+  WHISPER_CLI, WHISPER_MODEL, FFMPEG, WORKSPACE, CONFIG_DIR,
+  botSubprocessEnv,
+} = require("./config");
+const { redactSensitive, stripTerminalControls } = require("./redact");
+const { isClaudeAuthErrorText, isCodexAuthErrorText, claudeSubprocessEnv } = require("./auth-flow");
+
+function shellQuote(value) {
+  return `"${String(value).replace(/"/g, '\\"')}"`;
+}
+
+function runCommandForDoctor(command, args = [], opts = {}) {
+  try {
+    const out = execSync([command, ...args].map(shellQuote).join(" "), {
+      cwd: opts.cwd || process.env.HOME || require("os").homedir(),
+      env: opts.env || botSubprocessEnv(),
+      encoding: "utf-8",
+      timeout: opts.timeout || 10000,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    return { ok: true, output: out.trim(), code: 0 };
+  } catch (e) {
+    return { ok: false, output: `${e.stdout || ""}\n${e.stderr || ""}\n${e.message || ""}`.trim(), code: e.status ?? 1 };
+  }
+}
+
+function binaryCheck(binPath, name) {
+  if (!binPath) return { ok: false, label: name, detail: "not configured/found" };
+  try {
+    if (fs.existsSync(binPath)) fs.accessSync(binPath, fs.constants.X_OK);
+    else execSync(process.platform === "win32" ? `where ${shellQuote(binPath)}` : `which ${shellQuote(binPath)}`, { stdio: "ignore", env: botSubprocessEnv() });
+    return { ok: true, label: name, detail: binPath };
+  } catch (e) {
+    return { ok: false, label: name, detail: `not executable: ${binPath}` };
+  }
+}
+
+function checkWritableDir(dirPath, label) {
+  if (!dirPath) return { ok: false, label, detail: "not configured" };
+  try {
+    if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+    const test = path.join(dirPath, `.open-claudia-write-test-${Date.now()}`);
+    fs.writeFileSync(test, "ok");
+    fs.unlinkSync(test);
+    return { ok: true, label, detail: dirPath };
+  } catch (e) {
+    return { ok: false, label, detail: redactSensitive(e.message) };
+  }
+}
+
+function summarize(output, ok) {
+  const clean = redactSensitive(stripTerminalControls(output || "")).replace(/\s+/g, " ").trim();
+  if (!clean) return ok ? "ok" : "no output";
+  return clean.length > 160 ? clean.slice(0, 157) + "..." : clean;
+}
+
+function runDoctorChecks() {
+  const checks = [];
+  const nodeMajor = parseInt(process.version.slice(1).split(".")[0], 10);
+  checks.push({ ok: nodeMajor >= 18, label: "Node.js", detail: process.version, action: nodeMajor >= 18 ? "" : "Install Node.js 18+." });
+
+  const claudeBin = binaryCheck(CLAUDE_PATH, "Claude CLI");
+  if (claudeBin.ok) {
+    const ver = runCommandForDoctor(CLAUDE_PATH, ["--version"]);
+    const auth = runCommandForDoctor(CLAUDE_PATH, ["auth", "status"], { env: claudeSubprocessEnv(), timeout: 12000 });
+    checks.push({ ok: ver.ok, label: "Claude version", detail: summarize(ver.output, ver.ok), action: ver.ok ? "" : "Check CLAUDE_PATH." });
+    checks.push({ ok: auth.ok && !isClaudeAuthErrorText(auth.output), label: "Claude auth", detail: summarize(auth.output, auth.ok), action: auth.ok && !isClaudeAuthErrorText(auth.output) ? "" : "Run /auth_status then /setup_token or /login." });
+  } else checks.push({ ...claudeBin, action: "Install @anthropic-ai/claude-code or fix CLAUDE_PATH." });
+
+  if (CURSOR_PATH || resolvedCursorPath) {
+    const cursorPath = resolvedCursorPath || CURSOR_PATH;
+    const cursorBin = binaryCheck(cursorPath, "Cursor Agent");
+    if (cursorBin.ok) {
+      const ver = runCommandForDoctor(cursorPath, ["--version"]);
+      const status = runCommandForDoctor(cursorPath, ["status"], { timeout: 12000 });
+      checks.push({ ok: ver.ok, label: "Cursor version", detail: summarize(ver.output, ver.ok), action: ver.ok ? "" : "Check CURSOR_PATH." });
+      checks.push({ ok: status.ok, label: "Cursor auth/status", detail: summarize(status.output, status.ok), action: status.ok ? "" : "Run `agent login` on this host." });
+    } else checks.push({ ...cursorBin, action: "Install Cursor Agent or fix CURSOR_PATH." });
+  } else checks.push({ ok: true, warn: true, label: "Cursor Agent", detail: "not configured/found (optional)", action: "Install only if you want /cursor." });
+
+  if (CODEX_PATH || resolvedCodexPath) {
+    const codexPath = resolvedCodexPath || CODEX_PATH;
+    const codexBin = binaryCheck(codexPath, "Codex CLI");
+    if (codexBin.ok) {
+      const ver = runCommandForDoctor(codexPath, ["--version"]);
+      const status = runCommandForDoctor(codexPath, ["login", "status"], { timeout: 12000 });
+      checks.push({ ok: ver.ok, label: "Codex version", detail: summarize(ver.output, ver.ok), action: ver.ok ? "" : "Check CODEX_PATH." });
+      checks.push({ ok: status.ok && !isCodexAuthErrorText(status.output), label: "Codex auth", detail: summarize(status.output, status.ok), action: status.ok && !isCodexAuthErrorText(status.output) ? "" : "Run /codex_login or /codex_setup_token." });
+    } else checks.push({ ...codexBin, action: "Install @openai/codex or fix CODEX_PATH." });
+  } else checks.push({ ok: true, warn: true, label: "Codex CLI", detail: "not configured/found (optional)", action: "Install only if you want /codex." });
+
+  if (FFMPEG || WHISPER_CLI || WHISPER_MODEL) {
+    const ff = binaryCheck(FFMPEG || "ffmpeg", "ffmpeg");
+    const wh = binaryCheck(WHISPER_CLI, "Whisper CLI");
+    checks.push({ ...ff, action: ff.ok ? "" : "Install ffmpeg or set FFMPEG." });
+    checks.push({ ...wh, action: wh.ok ? "" : "Install whisper.cpp or set WHISPER_CLI." });
+    checks.push({ ok: !!WHISPER_MODEL && fs.existsSync(WHISPER_MODEL), label: "Whisper model", detail: WHISPER_MODEL || "not configured", action: WHISPER_MODEL ? "Check model path." : "Set WHISPER_MODEL for voice notes." });
+  } else checks.push({ ok: true, warn: true, label: "Voice stack", detail: "not configured (optional)", action: "Set FFMPEG/WHISPER_CLI/WHISPER_MODEL for voice notes." });
+
+  checks.push(checkWritableDir(WORKSPACE, "Workspace writable"));
+  checks.push(checkWritableDir(CONFIG_DIR, "Config dir writable"));
+  return checks;
+}
+
+function formatDoctorReport(checks) {
+  const hardProblems = checks.filter((c) => !c.ok && !c.warn);
+  const warnings = checks.filter((c) => c.warn || (!c.ok && c.warn));
+  const lines = [hardProblems.length ? "Open Claudia doctor found issues" : "Open Claudia doctor looks good", ""];
+  for (const c of checks) {
+    const icon = c.ok ? (c.warn ? "[!]" : "[ok]") : "[!]";
+    lines.push(`${icon} ${c.label}: ${c.detail || (c.ok ? "ok" : "issue")}`);
+  }
+  const actions = checks.filter((c) => (!c.ok || c.warn) && c.action).map((c) => `- ${c.label}: ${c.action}`);
+  if (actions.length) lines.push("", "Next actions:", ...actions.slice(0, 8));
+  if (warnings.length && !hardProblems.length) lines[0] = "Core requirements pass (optional items noted)";
+  return lines.join("\n");
+}
+
+module.exports = { runDoctorChecks, formatDoctorReport };