@inetafrica/open-claudia 2.0.2 → 2.0.4

package/core/scheduler.js

@@ -0,0 +1,249 @@
+// Unified scheduler — owns every timer the bot has running. Replaces
+// the old core/cron.js. Loads jobs.json on boot, schedules wakeups
+// (setTimeout) and crons (node-cron), and fires each one in the right
+// chat context with the right session pinned.
+//
+// When a wakeup fires the agent wakes up inside the SAME Claude session
+// it was in when it scheduled the wakeup (per design choice a/i). If
+// the channel is busy with a live turn the fire is deferred 30s and
+// retried. One-shot wakeups self-delete; crons persist.
+
+const path = require("path");
+const fs = require("fs");
+const cron = require("node-cron");
+
+const { CRONS_FILE, WORKSPACE, CHAT_ID } = require("./config");
+const jobs = require("./jobs");
+const { runInChat } = require("./context");
+const { getUserState, userStates } = require("./state");
+const { canonicalForTelegram, canonicalForChannel } = require("./identity");
+const { send } = require("./io");
+
+const MISSED_WAKEUP_GRACE_MS = 60 * 60 * 1000;
+const DEFER_BUSY_MS = 30 * 1000;
+
+const timers = new Map();
+let adapters = [];
+
+function setAdapters(list) {
+  adapters = Array.isArray(list) ? list.slice() : [];
+}
+
+function resolveAdapter(job) {
+  if (job.adapter) {
+    const byId = adapters.find((a) => a.id === job.adapter);
+    if (byId) return byId;
+  }
+  if (job.adapterType) {
+    const byType = adapters.find((a) => a.type === job.adapterType);
+    if (byType) return byType;
+  }
+  return adapters[0] || null;
+}
+
+function projectDir(job) {
+  if (!job.project) return null;
+  if (path.isAbsolute(job.project)) return job.project;
+  if (!WORKSPACE) return null;
+  return path.join(WORKSPACE, job.project);
+}
+
+function deriveCanonicalUserId(adapter, job) {
+  if (job.canonicalUserId) return job.canonicalUserId;
+  if (!adapter) return null;
+  return canonicalForChannel(adapter.type, job.channelId);
+}
+
+function deriveUserId(adapter, job) {
+  if (job.userId) return String(job.userId);
+  if (adapter && adapter.type === "telegram") return String(job.channelId);
+  return String(job.canonicalUserId || job.channelId || "");
+}
+
+async function fireJob(job, retry = 0) {
+  const adapter = resolveAdapter(job);
+  if (!adapter) {
+    console.error(`scheduler: no adapter for job ${job.id} (${job.label || job.kind})`);
+    return;
+  }
+  const canonicalUserId = deriveCanonicalUserId(adapter, job);
+  const userId = deriveUserId(adapter, job);
+
+  const ctx = {
+    adapter,
+    channelId: String(job.channelId),
+    canonicalUserId,
+    userId,
+    transport: adapter.type,
+    raw: null,
+  };
+
+  await runInChat(ctx, async () => {
+    const state = getUserState(canonicalUserId);
+    if (state.runningProcess) {
+      if (retry < 4) {
+        console.log(`scheduler: ${job.id} busy, deferring ${DEFER_BUSY_MS / 1000}s (retry ${retry + 1})`);
+        setTimeout(() => fireJob(job, retry + 1), DEFER_BUSY_MS);
+        return;
+      }
+      console.warn(`scheduler: ${job.id} still busy after retries, skipping`);
+      jobs.update(job.id, { lastFireAt: Date.now(), lastFireOk: false });
+      return;
+    }
+
+    const cwd = projectDir(job) || (state.currentSession && state.currentSession.dir) || WORKSPACE || process.cwd();
+    const label = job.label || (job.kind === "cron" ? "Scheduled cron" : "Scheduled wakeup");
+
+    try {
+      await send(`Wakeup: ${label}`);
+    } catch (e) { /* non-fatal */ }
+
+    const wrappedPrompt = job.kind === "cron"
+      ? `[Scheduled cron \"${label}\" fired at ${new Date().toISOString()}]\n${job.prompt}`
+      : `[Scheduled wakeup \"${label}\" fired at ${new Date().toISOString()}]\n${job.prompt}`;
+
+    const { runClaude } = require("./runner");
+    const runOpts = {};
+    if (job.sessionId) runOpts.resumeSessionId = job.sessionId;
+    try {
+      await runClaude(wrappedPrompt, cwd, null, runOpts);
+      jobs.update(job.id, { lastFireAt: Date.now(), lastFireOk: true });
+    } catch (e) {
+      console.error(`scheduler: ${job.id} run error:`, e.message);
+      jobs.update(job.id, { lastFireAt: Date.now(), lastFireOk: false });
+      try { await send(`Wakeup "${label}" failed: ${e.message}`); } catch (_) {}
+    }
+  });
+
+  if (job.kind === "wakeup") {
+    jobs.remove(job.id);
+    timers.delete(job.id);
+  }
+}
+
+function scheduleJob(job) {
+  if (timers.has(job.id)) {
+    const prev = timers.get(job.id);
+    if (prev.stop) prev.stop();
+    if (prev.timeout) clearTimeout(prev.timeout);
+    timers.delete(job.id);
+  }
+  if (job.kind === "wakeup") {
+    const delay = Math.max(0, (job.fireAt || 0) - Date.now());
+    const timeout = setTimeout(() => fireJob(job), delay);
+    timers.set(job.id, { timeout });
+  } else if (job.kind === "cron") {
+    if (!cron.validate(job.schedule)) {
+      console.error(`scheduler: invalid cron schedule for ${job.id}: ${job.schedule}`);
+      return;
+    }
+    const task = cron.schedule(job.schedule, () => fireJob(job));
+    timers.set(job.id, { stop: () => task.stop() });
+  }
+}
+
+function unscheduleJob(id) {
+  const t = timers.get(id);
+  if (!t) return;
+  if (t.stop) t.stop();
+  if (t.timeout) clearTimeout(t.timeout);
+  timers.delete(id);
+}
+
+function migrateLegacyCrons() {
+  try {
+    if (!CRONS_FILE || !fs.existsSync(CRONS_FILE)) return 0;
+    const raw = JSON.parse(fs.readFileSync(CRONS_FILE, "utf-8"));
+    if (!Array.isArray(raw) || raw.length === 0) return 0;
+    const existing = new Set(jobs.listAll().map((j) => j.id));
+    const tg = adapters.find((a) => a.type === "telegram");
+    const adapterId = tg ? tg.id : (adapters[0] && adapters[0].id);
+    const adapterType = tg ? "telegram" : (adapters[0] && adapters[0].type);
+    const channelId = tg ? (CHAT_ID || "") : "";
+    const canonicalUserId = adapterType === "telegram"
+      ? canonicalForTelegram(CHAT_ID || "")
+      : canonicalForChannel(adapterType || "", channelId);
+    let migrated = 0;
+    for (const c of raw) {
+      if (!c || !c.schedule || !c.prompt) continue;
+      if (c.id && existing.has(c.id)) continue;
+      jobs.add({
+        id: c.id || jobs.nextId("cron"),
+        kind: "cron",
+        adapter: adapterId,
+        adapterType,
+        channelId: String(channelId),
+        canonicalUserId,
+        project: c.project || null,
+        prompt: c.prompt,
+        label: c.label || (c.prompt || "").slice(0, 50),
+        source: "user",
+        schedule: c.schedule,
+        sessionKey: null,
+        sessionId: null,
+      });
+      migrated++;
+    }
+    if (migrated > 0) {
+      const backup = `${CRONS_FILE}.migrated`;
+      try { fs.renameSync(CRONS_FILE, backup); } catch (e) {}
+      console.log(`scheduler: migrated ${migrated} legacy cron(s) to jobs.json (backup: ${backup})`);
+    }
+    return migrated;
+  } catch (e) {
+    console.error("scheduler: legacy migration failed:", e.message);
+    return 0;
+  }
+}
+
+function fireMissedWakeupsOnce() {
+  const now = Date.now();
+  for (const job of jobs.listAll()) {
+    if (job.kind !== "wakeup") continue;
+    if (!job.fireAt) continue;
+    if (job.fireAt >= now) continue;
+    if (now - job.fireAt > MISSED_WAKEUP_GRACE_MS) {
+      jobs.remove(job.id);
+      continue;
+    }
+    setTimeout(() => fireJob({ ...job, label: `${job.label || "wakeup"} (missed)` }), 1000);
+  }
+}
+
+function initScheduler(adapterList) {
+  setAdapters(adapterList);
+  migrateLegacyCrons();
+  for (const job of jobs.listAll()) {
+    try { scheduleJob(job); }
+    catch (e) { console.error(`scheduler: failed to schedule ${job.id}:`, e.message); }
+  }
+  fireMissedWakeupsOnce();
+  console.log(`scheduler: loaded ${jobs.listAll().length} job(s)`);
+}
+
+function addJob(spec) {
+  const job = jobs.add(spec);
+  try { scheduleJob(job); }
+  catch (e) { console.error(`scheduler: failed to schedule new ${job.id}:`, e.message); }
+  return job;
+}
+
+function removeJob(id) {
+  unscheduleJob(id);
+  return jobs.remove(id);
+}
+
+function stopAll() {
+  for (const [id] of timers) unscheduleJob(id);
+}
+
+module.exports = {
+  setAdapters,
+  initScheduler,
+  scheduleJob,
+  unscheduleJob,
+  addJob,
+  removeJob,
+  stopAll,
+  fireJob,
+};

package/core/subagent.js

@@ -0,0 +1,109 @@
+// Sub-agents: spawn a fresh, throwaway Claude process for focused
+// research or sub-tasks. No session resume, no shared state with the
+// caller's turn — the output is captured as text and returned. The
+// caller (a parent Claude turn invoking the CLI via Bash) decides what
+// to do with the result.
+
+const { spawn } = require("child_process");
+const { CLAUDE_PATH, MAX_PROCESS_TIMEOUT, botSubprocessEnv } = require("./config");
+const { redactSensitive } = require("./redact");
+const { claudeSubprocessEnv } = require("./auth-flow");
+
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+const MAX_OUTPUT_BYTES = 64 * 1024;
+
+const concurrentByChannel = new Map();
+
+function buildSubagentSystemPrompt(role) {
+  return [
+    "You are a sub-agent spawned by another Claude assistant via Open Claudia.",
+    "Your reply is captured as raw text and returned to the parent agent — there is no user reading it directly.",
+    "Stay focused on the prompt. Be concise. Return findings; do not chat.",
+    "You do not have access to the parent's chat session, files in /tmp from the parent, or the loopback send tools.",
+    "You can use Read, Glob, Grep, Bash for read-only research. Do not start long-running processes.",
+    role ? `Role: ${role}` : "",
+  ].filter(Boolean).join("\n");
+}
+
+function trackStart(channelId) {
+  if (!channelId) return 0;
+  const cur = concurrentByChannel.get(channelId) || 0;
+  concurrentByChannel.set(channelId, cur + 1);
+  return cur + 1;
+}
+
+function trackEnd(channelId) {
+  if (!channelId) return;
+  const cur = concurrentByChannel.get(channelId) || 0;
+  if (cur <= 1) concurrentByChannel.delete(channelId);
+  else concurrentByChannel.set(channelId, cur - 1);
+}
+
+function concurrentCount(channelId) {
+  return concurrentByChannel.get(channelId) || 0;
+}
+
+async function spawnSubagent(prompt, opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const role = opts.role || null;
+  const channelId = opts.channelId || null;
+  const timeoutMs = Math.min(opts.timeoutMs || DEFAULT_TIMEOUT_MS, MAX_PROCESS_TIMEOUT || DEFAULT_TIMEOUT_MS);
+
+  const count = trackStart(channelId);
+  if (count > 3) {
+    console.warn(`subagent: ${count} concurrent sub-agents on channel ${channelId}`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const args = [
+      "-p",
+      "--output-format", opts.json ? "json" : "text",
+      "--verbose",
+      "--append-system-prompt", buildSubagentSystemPrompt(role),
+      "--dangerously-skip-permissions",
+      prompt,
+    ];
+    const env = { ...botSubprocessEnv(), ...claudeSubprocessEnv() };
+    const proc = spawn(CLAUDE_PATH, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+
+    let out = "";
+    let err = "";
+    let truncated = false;
+
+    proc.stdout.on("data", (d) => {
+      if (out.length + d.length > MAX_OUTPUT_BYTES) {
+        out += d.toString().slice(0, Math.max(0, MAX_OUTPUT_BYTES - out.length));
+        truncated = true;
+      } else {
+        out += d.toString();
+      }
+    });
+    proc.stderr.on("data", (d) => {
+      if (err.length < MAX_OUTPUT_BYTES) err += d.toString();
+    });
+
+    const t = setTimeout(() => {
+      try { proc.kill("SIGTERM"); } catch (e) {}
+      reject(new Error(`subagent timed out after ${Math.round(timeoutMs / 1000)}s`));
+    }, timeoutMs);
+
+    proc.on("error", (e) => {
+      clearTimeout(t);
+      trackEnd(channelId);
+      reject(e);
+    });
+    proc.on("close", (code) => {
+      clearTimeout(t);
+      trackEnd(channelId);
+      const text = redactSensitive(out.trim());
+      const stderrText = redactSensitive(err.trim());
+      if (code !== 0 && !text) {
+        const msg = stderrText || `subagent exited with code ${code}`;
+        return reject(new Error(msg));
+      }
+      resolve({ text, truncated, stderr: stderrText, code });
+    });
+  });
+}
+
+module.exports = { spawnSubagent, concurrentCount };

package/core/system-prompt.js

@@ -51,6 +51,27 @@ Reply normally in your final answer. To send a file, image, or voice clip back t
 - \`open-claudia send-voice <path>\` — ogg/opus voice note
 Never print or embed bot tokens in prompts, commands, logs, or messages.
 
+## Background work
+You can persist work across turns and wake yourself up later. These survive bot restarts.
+
+Wake-ups and crons (real schedulers, not hallucinations — use them instead of saying "I'll check back later"):
+- \`open-claudia schedule-wakeup <when> "<prompt>"\` — one-shot. \`<when>\` is a duration like \`30s\`/\`5m\`/\`2h\`/\`1d\` or an ISO datetime. When it fires you wake up in this same conversation with the prompt as if the user typed it.
+- \`open-claudia cron-add "<5-field cron>" "<prompt>"\` — recurring.
+- \`open-claudia cron-list\` — list all wakeups + crons on this channel.
+- \`open-claudia cron-remove <id>\` — cancel one.
+
+Persistent todo list (per channel; use for multi-step work so progress survives compaction):
+- \`open-claudia task add "<content>"\`
+- \`open-claudia task list\`
+- \`open-claudia task start <id>\` / \`task done <id>\` / \`task remove <id>\`
+
+Sub-agents (spawn a fresh throwaway Claude for focused research — output comes back on stdout):
+- \`open-claudia agent "<prompt>" [--role "<role>"]\`
+- Use when a side question would pollute this conversation, or to fan out independent lookups.
+- The sub-agent has Read/Glob/Grep/Bash but no access to your chat session or send-* tools.
+
+If you tell the user "I'll check back in N minutes" or "I'll run this every morning", you MUST schedule it with one of the commands above in the same turn. Otherwise nothing happens.
+
 ## Guidelines
 - Keep responses concise — many users are on mobile.
 - Markdown: *bold*, _italic_, \`code\`, \`\`\`code blocks\`\`\` work on both Telegram and Kazee. Skip headers (#) and links [text](url).

package/core/tasks.js

@@ -0,0 +1,92 @@
+// Per-channel persistent todo list. The agent uses this to track
+// multi-step work that should survive a turn, a compaction, or a
+// restart. Scoped by adapter+channel so Telegram and Kazee see
+// separate lists.
+
+const fs = require("fs");
+const path = require("path");
+const { TASKS_DIR } = require("./config");
+
+function safe(s) {
+  return String(s || "").replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 80);
+}
+
+function filePathFor(adapter, channelId) {
+  fs.mkdirSync(TASKS_DIR, { recursive: true });
+  return path.join(TASKS_DIR, `${safe(adapter)}-${safe(channelId)}.json`);
+}
+
+function load(adapter, channelId) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePathFor(adapter, channelId), "utf-8"));
+    return Array.isArray(raw) ? raw : [];
+  } catch (e) { return []; }
+}
+
+function save(adapter, channelId, list) {
+  const f = filePathFor(adapter, channelId);
+  const tmp = `${f}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(list, null, 2));
+  fs.renameSync(tmp, f);
+}
+
+function nextId() {
+  return `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function add(adapter, channelId, content) {
+  const list = load(adapter, channelId);
+  const t = {
+    id: nextId(),
+    content: String(content || "").trim(),
+    status: "pending",
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+  list.push(t);
+  save(adapter, channelId, list);
+  return t;
+}
+
+function update(adapter, channelId, id, patch) {
+  const list = load(adapter, channelId);
+  const idx = list.findIndex((t) => t.id === id);
+  if (idx < 0) return null;
+  list[idx] = { ...list[idx], ...patch, updatedAt: Date.now() };
+  save(adapter, channelId, list);
+  return list[idx];
+}
+
+function remove(adapter, channelId, id) {
+  const list = load(adapter, channelId);
+  const idx = list.findIndex((t) => t.id === id);
+  if (idx < 0) return null;
+  const [removed] = list.splice(idx, 1);
+  save(adapter, channelId, list);
+  return removed;
+}
+
+function clearCompleted(adapter, channelId) {
+  const list = load(adapter, channelId).filter((t) => t.status !== "completed");
+  save(adapter, channelId, list);
+  return list;
+}
+
+function list(adapter, channelId, opts = {}) {
+  const all = load(adapter, channelId);
+  if (opts.status) return all.filter((t) => t.status === opts.status);
+  return all;
+}
+
+function format(t, idx) {
+  const mark = t.status === "completed" ? "[x]" : t.status === "in_progress" ? "[~]" : "[ ]";
+  const num = typeof idx === "number" ? `${idx + 1}. ` : "";
+  return `${num}${mark} ${t.content}`;
+}
+
+module.exports = {
+  filePathFor,
+  load, save,
+  add, update, remove, list, clearCompleted,
+  format,
+};

package/package.json

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

package/core/cron.js

@@ -1,77 +0,0 @@
-// 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,
-};