zubo 0.1.0

package/src/registry/installer.ts

@@ -0,0 +1,67 @@
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { paths } from "../config/paths";
+import { getRegistryEntry } from "./client";
+import { logger } from "../util/logger";
+
+export interface InstallResult {
+  success: boolean;
+  name: string;
+  path?: string;
+  requiredSecrets?: string[];
+  error?: string;
+}
+
+export async function installFromRegistry(name: string): Promise<InstallResult> {
+  // Validate skill name — only allow safe characters to prevent path traversal
+  if (!/^[a-z0-9_-]+$/.test(name)) {
+    return { success: false, name, error: "Invalid skill name — only lowercase letters, numbers, hyphens, and underscores allowed" };
+  }
+
+  const entry = await getRegistryEntry(name);
+  if (!entry) {
+    return { success: false, name, error: `Skill "${name}" not found in registry` };
+  }
+
+  const skillDir = join(paths.skills, name);
+  // Verify resolved path stays within skills directory
+  const { resolve } = await import("path");
+  if (!resolve(skillDir).startsWith(resolve(paths.skills))) {
+    return { success: false, name, error: "Path traversal detected" };
+  }
+
+  if (existsSync(skillDir)) {
+    return { success: false, name, error: `Skill "${name}" is already installed` };
+  }
+
+  try {
+    // Fetch SKILL.md from the repo
+    const baseUrl = `https://raw.githubusercontent.com/${entry.repo}/main`;
+    const [skillMdRes, handlerRes] = await Promise.all([
+      fetch(`${baseUrl}/SKILL.md`),
+      fetch(`${baseUrl}/handler.ts`),
+    ]);
+
+    if (!skillMdRes.ok || !handlerRes.ok) {
+      return { success: false, name, error: `Failed to download skill files from ${entry.repo}` };
+    }
+
+    const skillMd = await skillMdRes.text();
+    const handler = await handlerRes.text();
+
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "SKILL.md"), skillMd);
+    writeFileSync(join(skillDir, "handler.ts"), handler);
+
+    logger.info(`Installed skill from registry: ${name}`);
+
+    return {
+      success: true,
+      name,
+      path: skillDir,
+      requiredSecrets: entry.secrets,
+    };
+  } catch (err: any) {
+    return { success: false, name, error: err.message };
+  }
+}

package/src/scheduler/briefing.ts

@@ -0,0 +1,71 @@
+import { Database } from "bun:sqlite";
+import type { LlmProvider } from "../llm/provider";
+import type { MessageRouter } from "../channels/router";
+import { agentLoop } from "../agent/loop";
+import { logger } from "../util/logger";
+
+const BRIEFING_TASK = `Generate a morning briefing for the user. Include:
+1. Any upcoming calendar events today (if Google Calendar is connected)
+2. Important unread emails (if Gmail is connected)
+3. Recent GitHub notifications (if GitHub is connected)
+4. Any pending tasks or reminders
+5. A brief weather-appropriate greeting
+
+Keep it concise and actionable. If services aren't connected, skip those sections gracefully.`;
+
+export async function generateMorningBriefing(
+  db: Database,
+  router: MessageRouter,
+  llm: LlmProvider
+): Promise<string> {
+  logger.info("Generating morning briefing...");
+
+  try {
+    const result = await agentLoop(llm, "briefing", BRIEFING_TASK, {
+      maxRounds: 5,
+    });
+
+    if (result.reply && router.broadcastProactive) {
+      await router.broadcastProactive(result.reply);
+    }
+
+    // Log the briefing
+    try {
+      db.prepare(
+        "INSERT INTO proactive_log (type, message) VALUES ('briefing', ?)"
+      ).run(result.reply.slice(0, 5000));
+    } catch (err: any) {
+      logger.warn("Failed to log briefing to database", { error: (err as Error).message });
+    }
+
+    return result.reply;
+  } catch (err: any) {
+    logger.error("Morning briefing failed", { error: err.message });
+    return "";
+  }
+}
+
+/**
+ * Ensure the morning briefing cron job exists.
+ * Called during startup to auto-create it.
+ */
+export function ensureBriefingCron(db: Database): void {
+  try {
+    const existing = db.query(
+      "SELECT id FROM cron_jobs WHERE name = 'zubo_morning_briefing'"
+    ).get();
+
+    if (!existing) {
+      db.prepare(
+        "INSERT INTO cron_jobs (name, schedule, task, enabled) VALUES (?, ?, ?, 1)"
+      ).run(
+        "zubo_morning_briefing",
+        "0 9 * * 1-5",
+        "Generate a morning briefing with calendar events, emails, and tasks for today."
+      );
+      logger.info("Created default morning briefing cron (weekdays at 9am)");
+    }
+  } catch {
+    // cron_jobs table may not exist yet
+  }
+}

package/src/scheduler/cron.ts

@@ -0,0 +1,258 @@
+import { Cron } from "croner";
+import { Database } from "bun:sqlite";
+import type { MessageRouter } from "../channels/router";
+import type { ZuboConfig } from "../config/schema";
+import type { LlmProvider } from "../llm/provider";
+import { delegateToAgent } from "../agent/delegate";
+import { logger } from "../util/logger";
+
+export interface CronJob {
+  id: number;
+  name: string;
+  schedule: string;
+  task: string;
+  enabled: number;
+  last_run: string | null;
+  retry_count: number;
+  max_retries: number;
+  agent: string | null;
+}
+
+const activeCrons: Map<number, Cron> = new Map();
+
+export function initCronScheduler(
+  db: Database,
+  router: MessageRouter,
+  config: ZuboConfig,
+  llm?: LlmProvider
+) {
+  const jobs = db
+    .query("SELECT * FROM cron_jobs WHERE enabled = 1")
+    .all() as CronJob[];
+
+  for (const job of jobs) {
+    scheduleJob(db, job, router, config, llm);
+  }
+
+  logger.info("Cron scheduler initialized", { jobCount: jobs.length });
+}
+
+function getOwnerSessionKey(config: ZuboConfig): string | null {
+  if (config.telegramAllowedUsers.length > 0) {
+    return `telegram:${config.telegramAllowedUsers[0]}`;
+  }
+  return null;
+}
+
+function scheduleJob(
+  db: Database,
+  job: CronJob,
+  router: MessageRouter,
+  config: ZuboConfig,
+  llm?: LlmProvider
+) {
+  if (activeCrons.has(job.id)) {
+    activeCrons.get(job.id)!.stop();
+  }
+
+  let cron: Cron;
+  try {
+    cron = new Cron(job.schedule, async () => {
+      logger.info(`Cron job firing: ${job.name}`);
+
+      const sessionKey = getOwnerSessionKey(config);
+      if (!sessionKey) {
+        logger.warn("No owner registered, skipping cron job");
+        return;
+      }
+
+      // Log start
+      const logResult = db
+        .prepare(
+          "INSERT INTO cron_logs (job_id, status) VALUES (?, 'running')"
+        )
+        .run(job.id);
+      const logId = Number(logResult.lastInsertRowid);
+
+      try {
+        let reply: string;
+
+        // If job has an agent and we have an LLM provider, delegate to the agent
+        if (job.agent && llm) {
+          reply = await delegateToAgent(llm, job.agent, job.task);
+        } else {
+          reply = await router.sendProactive(sessionKey, job.task);
+        }
+
+        // Log success
+        db.prepare(
+          "UPDATE cron_logs SET status = 'success', output = ?, finished_at = datetime('now') WHERE id = ?"
+        ).run(reply || "", logId);
+
+        // Update last_run
+        db.prepare(
+          "UPDATE cron_jobs SET last_run = datetime('now'), retry_count = 0 WHERE id = ?"
+        ).run(job.id);
+
+        // Send result to owner if delegated to agent
+        if (job.agent && llm && reply) {
+          const adapter = router as any;
+          try {
+            // Try to send through router's proactive channel
+            const sessionAdapter = (router as any).adapters ?? (router as any);
+            // Simplified: just log that the agent completed. The reply is already logged.
+            logger.info(`Agent "${job.agent}" completed cron task "${job.name}"`);
+          } catch {
+            // Non-critical, reply is already logged
+          }
+        }
+      } catch (err: any) {
+        logger.error(`Cron job failed: ${job.name}`, { error: err.message });
+
+        // Log failure
+        db.prepare(
+          "UPDATE cron_logs SET status = 'failed', error = ?, finished_at = datetime('now') WHERE id = ?"
+        ).run(err.message, logId);
+
+        // Increment retry count
+        const newRetry = job.retry_count + 1;
+        if (newRetry >= job.max_retries) {
+          logger.warn(
+            `Cron job disabled after ${job.max_retries} retries: ${job.name}`
+          );
+          db.prepare(
+            "UPDATE cron_jobs SET enabled = 0, retry_count = ? WHERE id = ?"
+          ).run(newRetry, job.id);
+          activeCrons.get(job.id)?.stop();
+          activeCrons.delete(job.id);
+        } else {
+          db.prepare(
+            "UPDATE cron_jobs SET retry_count = ? WHERE id = ?"
+          ).run(newRetry, job.id);
+        }
+      }
+    });
+  } catch (err: any) {
+    logger.error(`Invalid cron schedule for job '${job.name}'`, {
+      schedule: job.schedule,
+      error: err.message,
+    });
+    db.prepare("UPDATE cron_jobs SET enabled = 0 WHERE id = ?").run(job.id);
+    return;
+  }
+
+  activeCrons.set(job.id, cron);
+}
+
+const MAX_CRON_JOBS = 50;
+
+/**
+ * Validate a cron schedule is not too aggressive.
+ * Rejects schedules that fire more than once per minute.
+ */
+function validateCronSchedule(schedule: string): void {
+  // Quick check: if it has 6 fields (seconds), reject sub-minute schedules
+  const parts = schedule.trim().split(/\s+/);
+  if (parts.length === 6 && parts[0] !== "0") {
+    throw new Error(
+      "Sub-minute cron schedules are not allowed. Use at least 1-minute intervals."
+    );
+  }
+
+  // Try to parse and check next 2 runs are at least 60s apart
+  try {
+    const cron = new Cron(schedule);
+    const next1 = cron.nextRun();
+    const next2 = cron.nextRuns(2)[1];
+    if (next1 && next2) {
+      const gapMs = next2.getTime() - next1.getTime();
+      if (gapMs < 60_000) {
+        throw new Error(
+          "Cron schedule fires too frequently. Minimum interval is 1 minute."
+        );
+      }
+    }
+    cron.stop();
+  } catch (err: any) {
+    if (err.message?.includes("too frequently") || err.message?.includes("Sub-minute")) {
+      throw err;
+    }
+    throw new Error(`Invalid cron expression: ${schedule}`);
+  }
+}
+
+export function addCronJob(
+  db: Database,
+  name: string,
+  schedule: string,
+  task: string,
+  router: MessageRouter,
+  config: ZuboConfig,
+  agent?: string,
+  llm?: LlmProvider
+) {
+  // Validate schedule interval
+  validateCronSchedule(schedule);
+
+  // Enforce max active jobs
+  const activeCount = db
+    .query("SELECT COUNT(*) as c FROM cron_jobs WHERE enabled = 1")
+    .get() as { c: number };
+  if (activeCount.c >= MAX_CRON_JOBS) {
+    throw new Error(
+      `Maximum ${MAX_CRON_JOBS} active cron jobs allowed. Delete or disable some first.`
+    );
+  }
+
+  const result = db
+    .prepare(
+      "INSERT INTO cron_jobs (name, schedule, task, agent) VALUES (?, ?, ?, ?)"
+    )
+    .run(name, schedule, task, agent ?? null);
+
+  const id = Number(result.lastInsertRowid);
+  const job: CronJob = {
+    id,
+    name,
+    schedule,
+    task,
+    enabled: 1,
+    last_run: null,
+    retry_count: 0,
+    max_retries: 3,
+    agent: agent ?? null,
+  };
+
+  scheduleJob(db, job, router, config, llm);
+  logger.info(`Cron job added: ${name}`, { schedule, task, agent });
+}
+
+export function removeCronJob(db: Database, name: string): boolean {
+  const job = db
+    .query("SELECT id FROM cron_jobs WHERE name = ?")
+    .get(name) as { id: number } | null;
+  if (!job) return false;
+
+  if (activeCrons.has(job.id)) {
+    activeCrons.get(job.id)!.stop();
+    activeCrons.delete(job.id);
+  }
+
+  db.prepare("DELETE FROM cron_logs WHERE job_id = ?").run(job.id);
+  db.prepare("DELETE FROM cron_jobs WHERE id = ?").run(job.id);
+  logger.info(`Cron job removed: ${name}`);
+  return true;
+}
+
+export function listCronJobs(db: Database): CronJob[] {
+  return db
+    .query("SELECT * FROM cron_jobs ORDER BY created_at DESC")
+    .all() as CronJob[];
+}
+
+export function stopAllCrons() {
+  for (const [id, cron] of activeCrons) {
+    cron.stop();
+  }
+  activeCrons.clear();
+}

package/src/scheduler/heartbeat.ts

@@ -0,0 +1,58 @@
+import { logger } from "../util/logger";
+
+type HeartbeatHandler = () => Promise<void>;
+
+const handlers: HeartbeatHandler[] = [];
+let timer: ReturnType<typeof setInterval> | null = null;
+let currentIntervalMs = 30 * 60_000; // default 30 minutes
+
+const DEFAULT_HEARTBEAT_MINUTES = 30;
+
+export function onHeartbeat(handler: HeartbeatHandler) {
+  handlers.push(handler);
+}
+
+/**
+ * Start the heartbeat with a configurable interval.
+ * @param minutes — interval in minutes (default 30, min 1, max 1440)
+ */
+export function startHeartbeat(minutes?: number) {
+  if (timer) return;
+
+  const mins = Math.max(1, Math.min(1440, minutes ?? DEFAULT_HEARTBEAT_MINUTES));
+  currentIntervalMs = mins * 60_000;
+
+  logger.info("Heartbeat started", {
+    intervalMinutes: mins,
+  });
+
+  timer = setInterval(async () => {
+    if (handlers.length === 0) return;
+
+    // Run all handlers in parallel — one slow handler shouldn't block others
+    const results = await Promise.allSettled(handlers.map((h) => h()));
+    for (const r of results) {
+      if (r.status === "rejected") {
+        logger.error("Heartbeat handler error", { error: r.reason?.message ?? String(r.reason) });
+      }
+    }
+  }, currentIntervalMs);
+}
+
+export function stopHeartbeat() {
+  if (timer) {
+    clearInterval(timer);
+    timer = null;
+  }
+}
+
+/** Restart heartbeat with a new interval. */
+export function restartHeartbeat(minutes: number) {
+  stopHeartbeat();
+  startHeartbeat(minutes);
+}
+
+/** Get the current heartbeat interval in minutes. */
+export function getHeartbeatMinutes(): number {
+  return currentIntervalMs / 60_000;
+}

package/src/scheduler/memory-triggers.ts

@@ -0,0 +1,100 @@
+import { Database } from "bun:sqlite";
+import type { MessageRouter } from "../channels/router";
+import type { LlmProvider } from "../llm/provider";
+import { agentLoop } from "../agent/loop";
+import { logger } from "../util/logger";
+
+export interface MemoryTrigger {
+  id: number;
+  pattern: string;
+  action: string;
+  schedule: string;
+  last_fired: string | null;
+  enabled: number;
+}
+
+export async function checkMemoryTriggers(
+  db: Database,
+  router: MessageRouter,
+  llm: LlmProvider
+): Promise<void> {
+  let triggers: MemoryTrigger[];
+  try {
+    triggers = db.query(
+      "SELECT * FROM memory_triggers WHERE enabled = 1"
+    ).all() as MemoryTrigger[];
+  } catch {
+    return; // Table may not exist
+  }
+
+  if (triggers.length === 0) return;
+
+  const now = new Date();
+
+  for (const trigger of triggers) {
+    if (!shouldFire(trigger, now)) continue;
+
+    logger.info(`Firing memory trigger: ${trigger.pattern}`);
+
+    try {
+      // Search memory for the pattern
+      const { searchMemory } = await import("../memory/engine");
+      const results = searchMemory(db, trigger.pattern, 3);
+
+      if (results.length > 0) {
+        const context = results.map((r) => r.content).join("\n");
+        const task = `${trigger.action}\n\nRelevant context:\n${context}`;
+
+        const result = await agentLoop(llm, "trigger", task, { maxRounds: 3 });
+
+        if (result.reply && router.broadcastProactive) {
+          await router.broadcastProactive(result.reply);
+        }
+
+        // Log
+        try {
+          db.prepare(
+            "INSERT INTO proactive_log (type, message) VALUES ('trigger', ?)"
+          ).run(`[${trigger.pattern}] ${result.reply.slice(0, 2000)}`);
+        } catch (err: any) {
+          logger.warn("Failed to log trigger result to database", { error: (err as Error).message });
+        }
+      }
+
+      // Update last_fired
+      db.prepare(
+        "UPDATE memory_triggers SET last_fired = datetime('now') WHERE id = ?"
+      ).run(trigger.id);
+
+      // Disable if one-shot
+      if (trigger.schedule === "once") {
+        db.prepare(
+          "UPDATE memory_triggers SET enabled = 0 WHERE id = ?"
+        ).run(trigger.id);
+      }
+    } catch (err: any) {
+      logger.error(`Trigger error (${trigger.pattern})`, { error: err.message });
+    }
+  }
+}
+
+function shouldFire(trigger: MemoryTrigger, now: Date): boolean {
+  if (!trigger.last_fired) return true;
+
+  const lastFired = new Date(trigger.last_fired);
+  const diffMs = now.getTime() - lastFired.getTime();
+  const diffHours = diffMs / 3_600_000;
+
+  switch (trigger.schedule) {
+    case "once":
+      return !trigger.last_fired;
+    case "daily":
+      return diffHours >= 24;
+    case "weekly":
+      return diffHours >= 168;
+    case "monthly":
+      return diffHours >= 720;
+    default:
+      return diffHours >= 24;
+  }
+}