heyio 0.19.0 → 0.21.0

package/dist/api/server.js

@@ -14,13 +14,25 @@ import { requireAuth } from "./auth.js";
 import { listSchedules, getSchedule, deleteSchedule, setScheduleEnabled } from "../store/schedules.js";
 import { listIoSchedules, getIoSchedule, deleteIoSchedule, setIoScheduleEnabled } from "../store/io-schedules.js";
 import { getScheduleRuns } from "../store/schedule-runs.js";
-import { createInboxEntry, listInboxEntries, deleteInboxEntry, countInboxEntries } from "../store/inbox.js";
+import { createFeedEntry, listFeedEntries, countUnreadFeedEntries, markFeedEntryRead, markAllFeedEntriesRead, deleteFeedEntry, markFeedEntriesRead, deleteFeedEntries } from "../store/feed.js";
 import { listPages, readPage } from "../wiki/fs.js";
 import { runScheduleNow } from "../copilot/scheduler.js";
 import { runIoScheduleNow } from "../copilot/io-scheduler.js";
-import { listRecentNotifications, listUnreadNotifications, countUnreadNotifications, markNotificationRead, markAllNotificationsRead, } from "../store/notifications.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const WEB_DIST = path.resolve(__dirname, "../../web-dist");
+let releasesCache = null;
+function loadReleases() {
+    if (releasesCache)
+        return releasesCache;
+    try {
+        const raw = readFileSync(path.join(__dirname, "../releases.json"), "utf-8");
+        releasesCache = JSON.parse(raw);
+        return releasesCache;
+    }
+    catch {
+        return [];
+    }
+}
 let messageHandler;
 const sseConnections = new Set();
 export function setMessageHandler(handler) {
@@ -33,7 +45,7 @@ export function broadcastToSSE(text) {
     }
 }
 export function broadcastNotificationToSSE(payload) {
-    const data = JSON.stringify({ type: "notification", ...payload });
+    const data = JSON.stringify({ type: "feed", ...payload });
     for (const res of sseConnections) {
         res.write(`data: ${data}\n\n`);
     }
@@ -99,24 +111,53 @@ export async function startApiServer() {
             res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
         }
     });
-    // Inbox read endpoints
-    api.get("/inbox/count", (_req, res) => {
+    // Feed endpoints — unified deliverables + notifications feed
+    api.get("/feed/count", (req, res) => {
         try {
-            const count = countInboxEntries();
+            const rawType = req.query.type;
+            const type = rawType === "deliverable" || rawType === "notification"
+                ? rawType
+                : undefined;
+            const count = countUnreadFeedEntries(type);
             res.json({ count });
         }
         catch (e) {
-            console.error("Error counting inbox entries:", e);
+            console.error("Error counting feed entries:", e);
             res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
         }
     });
-    api.get("/inbox", (_req, res) => {
+    api.get("/feed", (req, res) => {
         try {
-            const entries = listInboxEntries();
-            res.json({ entries });
+            const rawType = req.query.type;
+            const type = rawType === "deliverable" || rawType === "notification"
+                ? rawType
+                : undefined;
+            const unreadOnly = req.query.unread === "true";
+            const rawLimit = req.query.limit;
+            const parsed = typeof rawLimit === "string" ? Number.parseInt(rawLimit, 10) : NaN;
+            const limit = Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, 200) : 50;
+            const rows = listFeedEntries({ type, unreadOnly, limit });
+            const unreadCount = countUnreadFeedEntries(type);
+            const entries = rows.map(({ id, type: entryType, title, body, created_at, read_at, source_type, source_ref }) => {
+                let source = null;
+                if (source_type) {
+                    source = { type: source_type };
+                    if (source_ref) {
+                        try {
+                            const parsedRef = JSON.parse(source_ref);
+                            source = { type: source_type, ...parsedRef };
+                        }
+                        catch {
+                            // source_ref is not valid JSON — fall back to type-only
+                        }
+                    }
+                }
+                return { id, type: entryType, title, body, created_at, read_at, source };
+            });
+            res.json({ entries, unreadCount });
         }
         catch (e) {
-            console.error("Error listing inbox entries:", e);
+            console.error("Error listing feed entries:", e);
             res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
         }
     });
@@ -124,38 +165,9 @@ export async function startApiServer() {
     api.get("/status", (_req, res) => {
         res.json({ version: IO_VERSION, uptime: process.uptime() });
     });
-    // Notifications endpoint
-    api.get("/notifications", (_req, res) => {
-        try {
-            const unreadOnly = _req.query.unread === "true";
-            const rows = unreadOnly
-                ? listUnreadNotifications()
-                : (() => {
-                    const rawLimit = _req.query.limit;
-                    const parsed = typeof rawLimit === "string" ? Number.parseInt(rawLimit, 10) : NaN;
-                    const limit = Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, 200) : 50;
-                    return listRecentNotifications(limit);
-                })();
-            const unreadCount = countUnreadNotifications();
-            const notifications = rows.map(({ id, title, text, created_at, read_at, source_type, source_ref }) => {
-                let source = { type: source_type };
-                if (source_ref) {
-                    try {
-                        const parsed = JSON.parse(source_ref);
-                        source = { type: source_type, ...parsed };
-                    }
-                    catch {
-                        // source_ref is not valid JSON — fall back to type-only
-                    }
-                }
-                return { id, title, text, created_at, read_at, source };
-            });
-            res.json({ notifications, unreadCount });
-        }
-        catch (e) {
-            console.error("Error listing notifications:", e);
-            res.status(500).json({ error: "Failed to list notifications" });
-        }
+    // Releases endpoint — serves build-time bundled GitHub release notes
+    api.get("/releases", (_req, res) => {
+        res.json({ releases: loadReleases() });
     });
     // SSE events endpoint
     api.get("/events", (req, res) => {
@@ -238,9 +250,78 @@ export async function startApiServer() {
             res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
         }
     });
-    // Inbox write endpoints — auth required
-    api.post("/inbox", (req, res) => {
-        const { title, body } = req.body;
+    // Feed write endpoints
+    // Note: POST /feed/read-all must be before POST /feed/:id/read to avoid route shadowing
+    api.post("/feed/read-all", (req, res) => {
+        try {
+            const rawType = req.query.type;
+            const type = rawType === "deliverable" || rawType === "notification"
+                ? rawType
+                : undefined;
+            const marked = markAllFeedEntriesRead(type);
+            res.json({ marked });
+        }
+        catch (e) {
+            console.error("Error marking feed entries read:", e);
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    api.post("/feed/batch-read", (req, res) => {
+        const { ids } = req.body;
+        if (!Array.isArray(ids) || ids.length === 0 || !ids.every((x) => typeof x === "number")) {
+            res.status(400).json({ error: "ids must be a non-empty array of numbers" });
+            return;
+        }
+        try {
+            const marked = markFeedEntriesRead(ids);
+            res.json({ marked });
+        }
+        catch (e) {
+            console.error("Error batch-marking feed entries read:", e);
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    api.post("/feed/batch-delete", (req, res) => {
+        const { ids } = req.body;
+        if (!Array.isArray(ids) || ids.length === 0 || !ids.every((x) => typeof x === "number")) {
+            res.status(400).json({ error: "ids must be a non-empty array of numbers" });
+            return;
+        }
+        try {
+            const deleted = deleteFeedEntries(ids);
+            res.json({ deleted });
+        }
+        catch (e) {
+            console.error("Error batch-deleting feed entries:", e);
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    api.post("/feed/:id/read", (req, res) => {
+        const raw = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+        const id = Number.parseInt(raw, 10);
+        if (Number.isNaN(id)) {
+            res.status(400).json({ error: "Invalid id" });
+            return;
+        }
+        try {
+            const found = markFeedEntryRead(id);
+            if (!found) {
+                res.status(404).json({ error: "Feed entry not found" });
+                return;
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            console.error("Error marking feed entry read:", e);
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    api.post("/feed", (req, res) => {
+        const { type, title, body, source_type, source_ref } = req.body;
+        if (type !== "deliverable" && type !== "notification") {
+            res.status(400).json({ error: "type must be 'deliverable' or 'notification'" });
+            return;
+        }
         if (!title || typeof title !== "string" || title.trim() === "") {
             res.status(400).json({ error: "Missing or empty required field: title" });
             return;
@@ -250,15 +331,21 @@ export async function startApiServer() {
             return;
         }
         try {
-            const entry = createInboxEntry(title.trim(), body.trim());
+            const entry = createFeedEntry({
+                type: type,
+                title: title.trim(),
+                body: body.trim(),
+                source_type: typeof source_type === "string" ? source_type : undefined,
+                source_ref: typeof source_ref === "string" ? source_ref : undefined,
+            });
             res.status(201).json({ entry });
         }
         catch (e) {
-            console.error("Error creating inbox entry:", e);
+            console.error("Error creating feed entry:", e);
             res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
         }
     });
-    api.delete("/inbox/:id", (req, res) => {
+    api.delete("/feed/:id", (req, res) => {
         const raw = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
         const id = Number.parseInt(raw, 10);
         if (Number.isNaN(id)) {
@@ -266,15 +353,15 @@ export async function startApiServer() {
             return;
         }
         try {
-            const deleted = deleteInboxEntry(id);
+            const deleted = deleteFeedEntry(id);
             if (!deleted) {
-                res.status(404).json({ error: "Inbox entry not found" });
+                res.status(404).json({ error: "Feed entry not found" });
                 return;
             }
             res.json({ deleted: true });
         }
         catch (e) {
-            console.error("Error deleting inbox entry:", e);
+            console.error("Error deleting feed entry:", e);
             res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
         }
     });
@@ -651,36 +738,6 @@ export async function startApiServer() {
             res.status(500).json({ error: (e instanceof Error ? e.message : String(e)) });
         }
     });
-    api.post("/notifications/read-all", (_req, res) => {
-        try {
-            const marked = markAllNotificationsRead();
-            res.json({ marked });
-        }
-        catch (e) {
-            console.error("Error marking all notifications read:", e);
-            res.status(500).json({ error: "Failed to mark notifications read" });
-        }
-    });
-    api.post("/notifications/:id/read", (req, res) => {
-        try {
-            const rawId = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
-            const id = Number.parseInt(rawId, 10);
-            if (Number.isNaN(id)) {
-                res.status(400).json({ error: "invalid id" });
-                return;
-            }
-            const found = markNotificationRead(id);
-            if (!found) {
-                res.status(404).json({ error: "notification not found" });
-                return;
-            }
-            res.json({ ok: true });
-        }
-        catch (e) {
-            console.error("Error marking notification read:", e);
-            res.status(500).json({ error: "Failed to mark notification read" });
-        }
-    });
     // Chat endpoints
     api.post("/message", async (req, res) => {
         const { text } = req.body;

package/dist/copilot/scheduler.js

@@ -16,7 +16,7 @@ import { delegateToAgent } from "./agents.js";
 import { nextRun } from "./cron.js";
 import { notifyBackground } from "../notify.js";
 import { startScheduleRun, completeScheduleRun, failScheduleRun } from "../store/schedule-runs.js";
-import { createInboxEntry } from "../store/inbox.js";
+import { createFeedEntry } from "../store/feed.js";
 import { shouldRouteToInbox } from "./tools.js";
 const TICK_MS = 30_000;
 const AGENDA_BLOCKS = {
@@ -83,7 +83,7 @@ async function fireSchedule(schedule) {
     try {
         await delegateToAgent(squad.slug, prompt, (_taskId, result) => {
             if (shouldRouteToInbox(prompt)) {
-                createInboxEntry(`[${squad.slug}] ${schedule.name}`, result);
+                createFeedEntry({ type: "deliverable", title: `[${squad.slug}] ${schedule.name}`, body: result });
                 console.error(`[io] Schedule ${schedule.id} result routed to inbox`);
                 completeScheduleRun(run.id, 0);
             }

package/dist/copilot/tools.js

@@ -5,7 +5,7 @@ import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSy
 import { join, dirname, resolve } from "path";
 import { homedir } from "os";
 import { UNIVERSES } from "./universes.js";
-import { createInboxEntry } from "../store/inbox.js";
+import { createFeedEntry } from "../store/feed.js";
 import { validateCron, nextRun } from "./cron.js";
 import { createIoSchedule, deleteIoSchedule, getIoSchedule, listIoSchedules, setIoScheduleEnabled, updateIoScheduleNextRun, } from "../store/io-schedules.js";
 import { runIoScheduleNow } from "./io-scheduler.js";
@@ -399,7 +399,7 @@ export function createTools(deps) {
                 const taskId = await deps.delegateToAgent(slug, task, (id, result) => {
                     console.error(`[io] Agent task ${id} completed for squad ${slug}`);
                     if (shouldRouteToInbox(task)) {
-                        createInboxEntry(`[${slug}] Task result`, result);
+                        createFeedEntry({ type: "deliverable", title: `[${slug}] Task result`, body: result });
                         console.error(`[io] Task ${id} result routed to inbox`);
                     }
                 }, agent);

package/dist/daemon.js

@@ -4,7 +4,7 @@ import { startApiServer, setMessageHandler as setApiHandler, broadcastNotificati
 import { createBot, startBot, stopBot, sendProactiveMessage, sendBackgroundNotification, setMessageHandler as setTelegramHandler } from "./telegram/bot.js";
 import { setTelegramSender, setTuiSender, setSseBroadcaster } from "./notify.js";
 import { pruneOldScheduleRuns } from "./store/schedule-runs.js";
-import { pruneOldNotifications } from "./store/notifications.js";
+import { pruneOldFeedEntries } from "./store/feed.js";
 import { printBackgroundNotification } from "./tui/index.js";
 import { getDb, closeDb } from "./store/db.js";
 import { clearStaleTasks } from "./store/tasks.js";
@@ -132,9 +132,9 @@ export async function startDaemon() {
     const pruneTimer = setInterval(() => {
         try {
             const runsDeleted = pruneOldScheduleRuns(PRUNE_RETENTION_DAYS);
-            const notificationsDeleted = pruneOldNotifications(PRUNE_RETENTION_DAYS);
+            const notificationsDeleted = pruneOldFeedEntries(PRUNE_RETENTION_DAYS);
             if (runsDeleted > 0 || notificationsDeleted > 0) {
-                console.log(`[prune] Cleaned up ${runsDeleted} schedule runs and ${notificationsDeleted} notifications older than ${PRUNE_RETENTION_DAYS} days`);
+                console.log(`[prune] Cleaned up ${runsDeleted} schedule runs and ${notificationsDeleted} feed entries older than ${PRUNE_RETENTION_DAYS} days`);
             }
         }
         catch (err) {
@@ -146,7 +146,7 @@ export async function startDaemon() {
     const pruneStartup = setTimeout(() => {
         try {
             pruneOldScheduleRuns(PRUNE_RETENTION_DAYS);
-            pruneOldNotifications(PRUNE_RETENTION_DAYS);
+            pruneOldFeedEntries(PRUNE_RETENTION_DAYS);
         }
         catch { /* best effort */ }
     }, 5000);

package/dist/notify.js

@@ -1,5 +1,5 @@
 import { config } from "./config.js";
-import { insertNotification, } from "./store/notifications.js";
+import { createFeedEntry } from "./store/feed.js";
 const HEARTBEAT_PATTERNS = [
     /^no active tasks?\.?$/i,
     /^nothing to report\.?$/i,
@@ -51,11 +51,12 @@ export async function notifyBackground(input) {
     const sourceRefJson = JSON.stringify(stripType(source));
     let row;
     try {
-        row = insertNotification({
+        row = createFeedEntry({
+            type: "notification",
+            title,
+            body: text,
             source_type: source.type,
             source_ref: sourceRefJson === "{}" ? null : sourceRefJson,
-            title,
-            text,
         });
     }
     catch (err) {

package/dist/store/db.js

@@ -160,6 +160,18 @@ GROUP BY agent_slug`,
       body TEXT NOT NULL,
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     )`,
+        `CREATE TABLE IF NOT EXISTS unified_feed (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL CHECK(type IN ('deliverable', 'notification')),
+      title TEXT NOT NULL,
+      body TEXT NOT NULL,
+      source_type TEXT,
+      source_ref TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      read_at DATETIME
+    )`,
+        `CREATE INDEX IF NOT EXISTS idx_unified_feed_type ON unified_feed(type, created_at)`,
+        `CREATE INDEX IF NOT EXISTS idx_unified_feed_unread ON unified_feed(read_at, created_at)`,
     ];
     for (const migration of migrations) {
         try {
@@ -169,6 +181,26 @@ GROUP BY agent_slug`,
             // Already applied — ignore
         }
     }
+    // One-time data migration: copy inbox_entries + background_notifications → unified_feed
+    try {
+        const migrated = db.prepare("SELECT value FROM io_state WHERE key = 'unified_feed_migrated'").get();
+        if (!migrated) {
+            db.exec(`
+        INSERT OR IGNORE INTO unified_feed (type, title, body, source_type, source_ref, created_at, read_at)
+        SELECT 'deliverable', title, body, NULL, NULL, created_at, NULL
+        FROM inbox_entries
+      `);
+            db.exec(`
+        INSERT OR IGNORE INTO unified_feed (type, title, body, source_type, source_ref, created_at, read_at)
+        SELECT 'notification', title, text, source_type, source_ref, created_at, read_at
+        FROM background_notifications
+      `);
+            db.prepare("INSERT OR REPLACE INTO io_state (key, value) VALUES ('unified_feed_migrated', '1')").run();
+        }
+    }
+    catch {
+        // Migration failed (e.g. old tables don't exist yet on a fresh install) — safe to ignore
+    }
     return db;
 }
 export function closeDb() {

package/dist/store/feed.js

@@ -0,0 +1,94 @@
+import { getDb } from "./db.js";
+export function createFeedEntry(input) {
+    const db = getDb();
+    const info = db
+        .prepare(`INSERT INTO unified_feed (type, title, body, source_type, source_ref)
+       VALUES (?, ?, ?, ?, ?)`)
+        .run(input.type, input.title, input.body, input.source_type ?? null, input.source_ref ?? null);
+    return db
+        .prepare("SELECT * FROM unified_feed WHERE id = ?")
+        .get(info.lastInsertRowid);
+}
+export function listFeedEntries(opts) {
+    const conditions = [];
+    const params = [];
+    if (opts?.type) {
+        conditions.push("type = ?");
+        params.push(opts.type);
+    }
+    if (opts?.unreadOnly) {
+        conditions.push("read_at IS NULL");
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = opts?.limit ?? 50;
+    params.push(limit);
+    return getDb()
+        .prepare(`SELECT * FROM unified_feed ${where} ORDER BY created_at DESC, id DESC LIMIT ?`)
+        .all(...params);
+}
+export function countUnreadFeedEntries(type) {
+    if (type) {
+        const row = getDb()
+            .prepare("SELECT COUNT(*) AS n FROM unified_feed WHERE read_at IS NULL AND type = ?")
+            .get(type);
+        return row.n;
+    }
+    const row = getDb()
+        .prepare("SELECT COUNT(*) AS n FROM unified_feed WHERE read_at IS NULL")
+        .get();
+    return row.n;
+}
+export function markFeedEntryRead(id) {
+    const db = getDb();
+    const info = db
+        .prepare("UPDATE unified_feed SET read_at = CURRENT_TIMESTAMP WHERE id = ? AND read_at IS NULL")
+        .run(id);
+    if (info.changes > 0)
+        return true;
+    // Idempotent: return true if row exists (already read), false if missing
+    const exists = db.prepare("SELECT id FROM unified_feed WHERE id = ?").get(id);
+    return exists !== undefined;
+}
+export function markAllFeedEntriesRead(type) {
+    if (type) {
+        const info = getDb()
+            .prepare("UPDATE unified_feed SET read_at = CURRENT_TIMESTAMP WHERE read_at IS NULL AND type = ?")
+            .run(type);
+        return info.changes;
+    }
+    const info = getDb()
+        .prepare("UPDATE unified_feed SET read_at = CURRENT_TIMESTAMP WHERE read_at IS NULL")
+        .run();
+    return info.changes;
+}
+export function deleteFeedEntry(id) {
+    const info = getDb()
+        .prepare("DELETE FROM unified_feed WHERE id = ?")
+        .run(id);
+    return info.changes > 0;
+}
+export function pruneOldFeedEntries(olderThanDays) {
+    const info = getDb()
+        .prepare(`DELETE FROM unified_feed WHERE created_at < datetime('now', '-' || ? || ' days')`)
+        .run(olderThanDays);
+    return info.changes;
+}
+export function markFeedEntriesRead(ids) {
+    if (ids.length === 0)
+        return 0;
+    const placeholders = ids.map(() => "?").join(", ");
+    const info = getDb()
+        .prepare(`UPDATE unified_feed SET read_at = CURRENT_TIMESTAMP WHERE id IN (${placeholders}) AND read_at IS NULL`)
+        .run(...ids);
+    return info.changes;
+}
+export function deleteFeedEntries(ids) {
+    if (ids.length === 0)
+        return 0;
+    const placeholders = ids.map(() => "?").join(", ");
+    const info = getDb()
+        .prepare(`DELETE FROM unified_feed WHERE id IN (${placeholders})`)
+        .run(...ids);
+    return info.changes;
+}
+//# sourceMappingURL=feed.js.map