heyio 1.13.0 → 3.0.1

package/README.md

@@ -1,333 +1,217 @@
-<img src="assets/IO-logo.svg" width="120"/>
-
-IO is a personal AI assistant daemon built on the GitHub Copilot SDK. It runs 24/7 on your machine, reachable via Telegram, a web dashboard, and an HTTP API.
-
-[![CI](https://github.com/michaeljolley/io/actions/workflows/ci.yml/badge.svg)](https://github.com/michaeljolley/io/actions/workflows/ci.yml)
-![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
-![Node.js](https://img.shields.io/badge/node-%3E%3D22-brightgreen)
-
-## ✨ Features
-
-- **Copilot SDK Integration** — powered by GitHub's Copilot SDK for LLM conversations with tool calling
-- **Multi-Interface** — Web dashboard + Telegram bot + HTTP API
-- **Web Frontend** — Vue 3 dashboard with chat, squad management, skills, and agent activity views
-- **Web Chat Attachments** — Attach images/files in web chat (10MB per file, 25MB per message) with multimodal handoff
-- **Persistent Memory** — wiki-based knowledge base stored at `~/.io/wiki/`
-- **Squad System** — persistent project teams with **named specialist agents** themed from pop culture universes (dynamically selected at squad creation)
-- **Skills** — modular skill system; install from git repos or the [skills.sh](https://skills.sh) registry
-- **Adaptive Sessions** — infinite sessions with automatic context compaction
-- **Named Agent Personas** — each squad agent gets a character persona with personality, dynamic role title, and specialized charter
-- **GitHub Integration** — create, list, view, and comment on issues and PRs via the `github` tool
-- **Smart Model Routing** — automatically selects the best model for each task based on complexity
-- **Self-Updating** — checks for updates and can apply them automatically
-- **MCP Integration** — Connect to external MCP servers for additional tools (Figma, databases, APIs)
-- **Scheduling** — Cron-based scheduling for recurring tasks and squad stand-ups
-- **Squad Instances** — Parallel worktrees for concurrent work within a single squad
-- **Unified Feed** — Consolidated inbox and notification feed with web UI
-- **Telegram Attachments** — Send images/files via Telegram for vision-capable model processing
-- **Agent Preview** — Live streaming preview of any squad agent's activity in the web UI
-- **Squad Wiki** — Per-squad wiki context included in agent prompts and instance snapshots
-- **Instance Watchdog** — Monitors active/merging instances and auto-aborts stale ones
-
-## 📋 Prerequisites
-
-- **Node.js** >= 22
-- **GitHub Copilot subscription** — IO uses the Copilot SDK, which requires an active Copilot license
-- **GitHub CLI** (`gh`) — required for the `github` tool (issue/PR management). Install from [cli.github.com](https://cli.github.com/) and authenticate with `gh auth login`
-
-## 🚀 Quick Start
-
-### Install
-
-```bash
-npm install -g heyio
+<p align="center">
+  <img src="assets/IO-logo.svg" alt="IO Logo" width="200" />
+</p>
+
+<h1 align="center">IO</h1>
+
+<p align="center">
+  <strong>AI Orchestrator Daemon — manage specialized agent squads for your software projects</strong>
+</p>
+
+<p align="center">
+  <a href="https://michaeljolley.github.io/io">Documentation</a> •
+  <a href="#getting-started">Getting Started</a> •
+  <a href="#architecture">Architecture</a>
+</p>
+
+---
+
+## What is IO?
+
+IO is an always-running daemon that acts as your personal AI orchestrator. You talk to IO, and IO manages teams of specialized AI agents ("squads") that work on your codebases.
+
+- **One conversation interface** — talk to IO via TUI, Telegram, or the web dashboard
+- **Squad delegation** — IO automatically routes project questions to the right squad
+- **Universe theming** — squads get pop-culture character names and personas via LLM
+- **Web dashboard** — React SPA with real-time chat, squad management, and usage charts
+- **Cron schedules** — automate recurring tasks like daily standups or issue triage
+- **Inbox system** — squads can send you deliverables or ask blocking questions
+- **Model management** — token tracking and configurable model selection per agent
+
+## Architecture
+
+```mermaid
+graph TD
+    User["🧑 You<br/>(TUI / Telegram / Web)"]
+    Orch["🤖 Orchestrator<br/>(Copilot SDK · tool-calling)"]
+    Wiki["📚 Wiki<br/>(Knowledge Base)"]
+    Skills["🧩 Skills<br/>(SKILL.md)"]
+    Sched["⏰ Scheduler<br/>(cron jobs)"]
+    SquadA["👥 Squad A<br/>(Team Lead + Agents)"]
+    SquadB["👥 Squad B<br/>(Team Lead + Agents)"]
+    Web["🌐 Web Dashboard<br/>(React SPA)"]
+
+    User --> Orch
+    User --> Web
+    Web --> Orch
+    Orch --> SquadA
+    Orch --> SquadB
+    Orch --> Sched
+    Orch --> Wiki
+    Orch --> Skills
+    SquadA --> Wiki
+    SquadB --> Wiki
 ```
 
-### Setup
+Each squad has:
+- **Team Lead** — receives objectives, creates plans, coordinates agents
+- **Agents** — specialized workers (developer, reviewer, etc.) with pop-culture character names
+- **Meetings** — structured collaboration between agents for planning and review
+- **QA/Tester** — required veto-holding member who must approve before completion
 
-Run the setup wizard to configure your Telegram bot token and user ID:
+## Getting Started
 
-```bash
-io setup
-```
+### Prerequisites
 
-This creates a config file at `~/.io/config.json`.
+- Node.js 22+
+- GitHub Copilot access (the daemon uses `@github/copilot-sdk`)
+- Git
 
-### Run
+### Installation
 
 ```bash
-# Background daemon (Telegram + HTTP API + Web)
-io --daemon
-
-# Allow IO to modify its own source code
-io --self-edit
+git clone https://github.com/michaeljolley/io.git
+cd io
+npm install
+npm run build
 ```
 
-### Headless Server (systemd)
-
-To run IO as a background service on a headless server:
+### Running
 
-1. Authenticate the Copilot SDK: `copilot login`
-2. Authenticate the GitHub CLI: `gh auth login`
-3. Create a systemd service file at `/etc/systemd/system/io.service`:
-
-```ini
-[Unit]
-Description=IO Personal Assistant
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=/usr/bin/env io --daemon
-Restart=always
-RestartSec=10
-Environment=NODE_ENV=production
+```bash
+# Start the daemon
+npm run dev
 
-[Install]
-WantedBy=multi-user.target
+# Or build and start
+npm run build
+npm start
 ```
 
-4. Enable and start: `systemctl enable --now io`
-
-## 💬 CLI Usage
-
-| Command | Description |
-| --- | --- |
-| `io --daemon` | Run as background daemon (Telegram + API + Web) |
-| `io --self-edit` | Allow IO to modify its own source |
-| `io setup` | Configure Telegram bot token and user ID |
-
-Skills are managed via the web dashboard.
-
-## ⚙️ Configuration
+The daemon starts on port `7777` by default. The web dashboard is served at the same port — open `http://localhost:7777` in your browser.
 
-IO stores its configuration at `~/.io/config.json`. The setup wizard (`io setup`) handles initial configuration, but you can also edit the file directly.
+### Configuration
 
-### Parameters
+Create `~/.io/config.json`:
 
-| Parameter | Type | Default | Description |
-| --- | --- | --- | --- |
-| `telegramBotToken` | `string` | — | Telegram bot token from [@BotFather](https://t.me/BotFather) |
-| `authorizedUserId` | `number` | — | Your Telegram user ID (only this user can interact with the bot) |
-| `telegramEnabled` | `boolean` | `false` | Enable the Telegram bot interface |
-| `selfEditEnabled` | `boolean` | `false` | Allow IO to modify its own source code |
-| `defaultModel` | `string` | `"gpt-4.1"` | LLM model for the main orchestrator session |
-| `port` | `number` | `3170` | Port for the HTTP server (API + web frontend) |
-| `supabaseUrl` | `string` | — | Supabase project URL (enables web portal authentication) |
-| `supabaseAnonKey` | `string` | — | Supabase anon/public API key |
-| `authorizedEmail` | `string` | — | Email address allowed to access the web portal |
-| `backgroundNotifyMode` | `string` | `"meaningful"` | Background task notification frequency: `"all"`, `"meaningful"`, or `"off"` |
-| `backgroundNotifyTelegram` | `boolean` | `true` | Send background task notifications via Telegram |
-| `watchdogEnabled` | `boolean` | `true` | Enable the daemon event loop watchdog |
-
-IO discovers available models from the Copilot SDK at startup and automatically picks the most appropriate model for each task based on complexity and cost.
-
-> **Migration note:** If your config uses the old `apiPort` field, IO will automatically migrate it to `port`.
-
-### Example
-
-```jsonc
+```json
 {
-  "telegramBotToken": "123456:ABC-DEF...",
-  "authorizedUserId": 123456789,
-  "telegramEnabled": true,
-  "selfEditEnabled": false,
-  "defaultModel": "claude-sonnet-4.6",
-  "port": 3170,
-  "supabaseUrl": "https://your-project.supabase.co",
-  "supabaseAnonKey": "eyJhbGciOiJIUzI1NiIs...",
-  "authorizedEmail": "you@example.com"
+  "apiPort": 7777,
+  "defaultModel": "claude-opus-4.6",
+  "logLevel": "info",
+  "maxInstancesPerSquad": 3,
+  "telegram": {
+    "botToken": "your-token-from-botfather",
+    "allowedChatIds": [12345678]
+  },
+  "supabase": {
+    "projectUrl": "https://your-project.supabase.co",
+    "anonKey": "eyJ...",
+    "jwtSecret": "your-jwt-secret"
+  }
 }
 ```
 
-All persistent data is stored under `~/.io/`:
-
-| Path | Purpose |
-| --- | --- |
-| `~/.io/config.json` | User configuration |
-| `~/.io/wiki/` | Knowledge base (markdown files) |
-| `~/.io/io.db` | SQLite database (squads, tasks) |
-| `~/.io/skills/` | Installed skills |
-| `~/.io/mcp.json` | MCP server configuration |
-
-## 🧩 Skills System
+All settings can also be controlled via environment variables (which take priority):
 
-Skills are modular extensions that add new tools and capabilities to IO. Each skill is a directory containing a `SKILL.md` manifest and tool definitions.
+| Variable | Config Key | Default |
+|----------|-----------|---------|
+| `IO_PORT` | `apiPort` | `7777` |
+| `IO_LOG_LEVEL` | `logLevel` | `info` |
+| `IO_MODEL` | `defaultModel` | `claude-opus-4.6` |
+| `IO_DATA_DIR` | `dataDir` | `~/.io` |
+| `TELEGRAM_BOT_TOKEN` | `telegram.botToken` | — |
+| `TELEGRAM_ALLOWED_CHAT_IDS` | `telegram.allowedChatIds` | — |
+| `IO_SUPABASE_URL` | `supabase.projectUrl` | — |
+| `IO_SUPABASE_ANON_KEY` | `supabase.anonKey` | — |
+| `IO_SUPABASE_JWT_SECRET` | `supabase.jwtSecret` | — |
 
-### Managing Skills
+See the [Configuration Guide](https://michaeljolley.github.io/io/guides/configuration/) for full details.
 
-Skills are managed through the web dashboard:
-
-- **View** all installed skills with name, description, and slug
-- **Install** new skills by providing a git repository URL
-- **Remove** skills you no longer need
+### Authentication
 
-### Creating a Skill
+When Supabase is configured, the web dashboard requires login and all API endpoints are secured with JWT verification. If Supabase is **not** configured, the API stays open (suitable for local-only use).
 
-A skill is a directory with a `SKILL.md` file that describes the skill and its tools. See the [Contributing Guide](CONTRIBUTING.md) for details on the skill format.
+## Key Features
 
-## 👥 Squad System
+### Squads
 
-Squads are persistent project teams with **named specialist agents**. Each squad:
+Hire a squad for any project:
 
-- Has a pop culture **universe theme** (dynamically researched at creation time — never hardcoded)
-- Contains dynamically-created **specialist agents** with roles tailored to the project (e.g., "Express API Engineer", "Vue.js Frontend Dev")
-- Each agent is assigned a **character persona** with personality traits that color their work style
-- Remembers decisions, context, and conversation history across sessions
-- Persists across sessions in the SQLite database
+> "Hire a squad for https://github.com/org/my-app with the Star Wars universe"
 
-### How Squads Work
+IO creates a team with character names from your chosen universe (e.g., "Yoda" as Team Lead, "R2-D2" as DevOps). Each member gets a persona that influences their communication style.
 
-1. **Create** — `squad_create` assigns a random pop culture universe (or user picks one)
-2. **Analyze** — `squad_analyze` scans the project to determine languages, frameworks, and tools
-3. **Build the team** — `squad_add_agent` for each specialist the project needs; characters are drawn from the universe pool
-4. **Delegate** — `squad_delegate` sends tasks to specific agents by character name
-5. **Track** — `squad_task_status` monitors progress and retrieves results
+### Web Dashboard
 
-## 🏗️ Architecture
+A full React SPA served by the daemon at the API port:
+- **Chat** — real-time streaming conversation with IO
+- **Squads** — view teams, members, active instances, and activity
+- **Feed** — inbox of deliverables and blocking questions
+- **Skills** — manage installed SKILL.md capabilities
+- **Schedules** — CRUD for cron-based automation
+- **Wiki** — knowledge base viewer and editor
+- **Usage** — token and cost charts (by squad, model, time)
+- **Settings** — configure all daemon options from the UI
 
-```
-User → [Web Dashboard / Telegram / HTTP API]
-                ↓
-         Orchestrator (Copilot SDK)
-          ↕           ↕          ↕
-     Squad Manager   Wiki/Memory  MCP Servers
-          ↓
-     Named Agents (Pop Culture Characters)
-```
+### Schedules
 
-IO is built around the **Copilot SDK** which handles all LLM interactions, including tool calling and context management. The **Orchestrator** manages the primary conversation session with automatic context compaction for infinite-length sessions.
+Automate recurring work with cron expressions:
 
-For complex tasks, the orchestrator delegates work to **Named Agents** — persistent agent sessions with character personas, specialized roles, and per-agent system prompts. Each agent works autonomously within their squad's project context.
+> "Create a daily standup for my-app at 9am on weekdays — have them review open issues and report progress"
 
-The **Squad System** provides persistent project context, while the **Wiki** serves as a long-term knowledge base that spans all conversations.
+### Inbox
 
-### Web Frontend
+Squads communicate back via the inbox:
+- **Deliverables** — status reports, completed summaries
+- **Blocking questions** — the squad pauses and waits for your answer
 
-IO includes a Vue 3 web dashboard served directly from the daemon on the same port as the API (default: 3170). The frontend provides:
+### Clients
 
-- **Chat** — real-time conversation with SSE streaming
-- **Squads** — view and manage project squads
-- **Skills** — browse installed skills
-- **Agent Activity** — monitor running worker agents
-
-Access the web UI at `http://your-server:3170/` when running in daemon mode.
-
-### Authentication
+| Client | Description |
+|--------|-------------|
+| Web Dashboard | React SPA at `http://localhost:7777` |
+| TUI | Terminal interface built with Ink |
+| Telegram | Bot integration via Grammy |
+| REST API | HTTP endpoints at `/api/*` |
+| WebSocket | Real-time streaming at `/ws` |
 
-The web portal uses Supabase email authentication. All API endpoints (except `/health`) require a valid JWT. Users must sign in with email and password before accessing the dashboard. Only the configured `authorizedEmail` is allowed access.
+## Project Structure
 
-**Setup:**
-
-1. Create a [Supabase](https://supabase.com) project (or use an existing one)
-2. Enable the **Email** auth provider in Supabase → Authentication → Providers
-3. Create your user account in Supabase → Authentication → Users
-4. Add the following to `~/.io/config.json`:
-
-```jsonc
-{
-  "supabaseUrl": "https://your-project.supabase.co",
-  "supabaseAnonKey": "eyJhbGciOiJIUzI1NiIs...",
-  "authorizedEmail": "you@example.com"
-}
 ```
-
-5. Restart IO — the web portal will now require login
-
-## 🏗️ Project Structure
-
-```
-src/
-├── index.ts              # CLI entry (commander)
-├── daemon.ts             # Daemon startup/shutdown
-├── config.ts             # Config loading
-├── paths.ts              # Path constants
-├── notify.ts             # Notification routing
-├── watchdog.ts           # Event loop stall + zombie detection
-├── copilot/
-│   ├── client.ts         # CopilotClient singleton
-│   ├── orchestrator.ts   # Main session management
-│   ├── agents.ts         # Named agent sessions & personas
-│   ├── tools.ts          # Tool definitions
-│   ├── model-router.ts   # Complexity-based model selection
-│   ├── skills.ts         # Skills loader
-│   ├── scheduler.ts      # Squad cron scheduler
-│   ├── io-scheduler.ts   # IO-level cron scheduler
-│   └── system-message.ts # System prompt builder
-├── store/
-│   ├── db.ts             # SQLite database
-│   ├── squads.ts         # Squad & agent CRUD
-│   ├── tasks.ts          # Agent task tracking
-│   ├── instances.ts      # Squad instance management
-│   ├── feed.ts           # Unified feed/inbox
-│   └── schedules.ts      # Schedule persistence
-├── wiki/
-│   ├── fs.ts             # Wiki filesystem
-│   └── search.ts         # Wiki search
-├── telegram/
-│   ├── bot.ts            # Grammy Telegram bot
-│   └── handlers.ts       # Command handlers
-├── mcp/
-│   ├── config.ts         # MCP server config
-│   ├── registry.ts       # Module-level tool registry
-│   └── index.ts          # MCP exports
-└── api/
-    ├── auth.ts           # Supabase JWT auth middleware
-    └── server.ts         # Express HTTP + SSE + static frontend
-
-web/                        # Vue 3 frontend (built to web-dist/)
-├── src/
-│   ├── lib/              # supabase.ts, api.ts (auth helpers)
-│   ├── stores/           # Pinia stores (chat, auth)
-│   ├── views/            # ChatView, SquadsView, FeedView, SkillsView, McpView, etc.
-│   ├── router/           # Vue Router config + auth guard
-│   └── main.ts           # App entry
-├── vite.config.ts        # Vite config (builds to ../web-dist/)
-└── package.json
-
-docs/                       # VitePress documentation site
-├── .vitepress/config.ts  # Site configuration
-├── guide/                # Getting started, configuration, etc.
-├── architecture/         # System design documentation
-├── reference/            # CLI, API, and tools reference
-└── package.json
+packages/
+├── shared/      # Types, constants, shared utilities
+├── daemon/      # Core daemon (orchestrator, squads, API, scheduler)
+├── web/         # Web dashboard (React + Vite + Tailwind)
+├── tui/         # Terminal UI (Ink/React)
+└── telegram/    # Telegram bot client
+docs/            # Astro Starlight documentation site
+.github/
+└── workflows/
+    ├── ci.yml           # PR validation (lint, build, test)
+    ├── release.yml      # Tag-based release + npm publish
+    └── deploy-docs.yml  # Docs site deployment
 ```
 
-## 🛠️ Development
+## Development
 
 ```bash
-# Clone the repository
-git clone https://github.com/michaeljolley/io.git
-cd io
-
-# Install dependencies
-npm install
-
-# Run in development mode (watch)
-npm run dev
-
-# Build for production
+# Build all packages
 npm run build
 
-# Build everything (backend + web)
-npm run build:all
+# Run daemon in dev mode (watches for changes)
+npm run dev
 
-# Run the daemon directly
-npm run daemon
+# Run web dashboard dev server (with API proxy)
+cd packages/web && npm run dev
 
-# Run the test suite
-npm test
+# Build documentation
+cd docs && npm run build
 ```
 
-Tests use the Node.js built-in test runner with [tsx](https://github.com/privatenumber/tsx) for TypeScript support. Test files live alongside source files as `*.test.ts`.
-
-See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed development guidelines.
-
-## 📄 License
+## Documentation
 
-This project is licensed under the [MIT License](LICENSE).
+Full documentation is available at **[michaeljolley.github.io/io](https://michaeljolley.github.io/io)**.
 
-## 🤝 Contributing
+## License
 
-Contributions are welcome! Please read the [Contributing Guide](CONTRIBUTING.md) and [Code of Conduct](CODE_OF_CONDUCT.md) before submitting a pull request.
+MIT

package/dist/api/middleware/auth.d.ts

@@ -0,0 +1,14 @@
+import type { NextFunction, Request, Response } from 'express';
+import type { IOConfig } from '../../config.js';
+/**
+ * Express middleware that verifies Supabase JWT tokens.
+ * If Supabase is not configured (no jwtSecret), all requests pass through.
+ * Exempt routes always pass through regardless of config.
+ */
+export declare function authMiddleware(config: IOConfig): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Verify a JWT token for WebSocket connections.
+ * Returns true if valid or if auth is not configured.
+ */
+export declare function verifyWsToken(config: IOConfig, token: string | null): boolean;
+//# sourceMappingURL=auth.d.ts.map

package/dist/api/middleware/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/api/middleware/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAehD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,QAAQ,IACtC,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,KAAG,IAAI,CA+B9D;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAe7E"}

package/dist/api/middleware/auth.js

@@ -0,0 +1,66 @@
+import jwt from 'jsonwebtoken';
+import { createChildLogger } from '../../logging/logger.js';
+const logger = () => createChildLogger('auth');
+// Routes that don't require authentication
+const EXEMPT_ROUTES = [
+    { method: 'GET', path: '/api/health' },
+    { method: 'GET', path: '/api/config' },
+];
+function isExempt(method, path) {
+    return EXEMPT_ROUTES.some((r) => r.method === method.toUpperCase() && path.startsWith(r.path));
+}
+/**
+ * Express middleware that verifies Supabase JWT tokens.
+ * If Supabase is not configured (no jwtSecret), all requests pass through.
+ * Exempt routes always pass through regardless of config.
+ */
+export function authMiddleware(config) {
+    return (req, res, next) => {
+        // If no Supabase JWT secret configured, skip auth entirely (local-only mode)
+        if (!config.supabase.jwtSecret) {
+            next();
+            return;
+        }
+        // Exempt routes don't require auth
+        if (isExempt(req.method, req.path)) {
+            next();
+            return;
+        }
+        const authHeader = req.headers.authorization;
+        if (!authHeader?.startsWith('Bearer ')) {
+            res.status(401).json({ error: 'Missing or invalid Authorization header' });
+            return;
+        }
+        const token = authHeader.slice(7);
+        try {
+            jwt.verify(token, config.supabase.jwtSecret, {
+                algorithms: ['HS256'],
+            });
+            next();
+        }
+        catch (err) {
+            logger().debug({ err }, 'JWT verification failed');
+            res.status(401).json({ error: 'Invalid or expired token' });
+        }
+    };
+}
+/**
+ * Verify a JWT token for WebSocket connections.
+ * Returns true if valid or if auth is not configured.
+ */
+export function verifyWsToken(config, token) {
+    if (!config.supabase.jwtSecret) {
+        return true; // No auth configured — allow
+    }
+    if (!token) {
+        return false;
+    }
+    try {
+        jwt.verify(token, config.supabase.jwtSecret, { algorithms: ['HS256'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=auth.js.map

package/dist/api/middleware/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../../src/api/middleware/auth.ts"],"names":[],"mappings":"AACA,OAAO,GAAG,MAAM,cAAc,CAAC;AAE/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D,MAAM,MAAM,GAAG,GAAG,EAAE,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;AAE/C,2CAA2C;AAC3C,MAAM,aAAa,GAA4C;IAC9D,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE;IACtC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE;CACtC,CAAC;AAEF,SAAS,QAAQ,CAAC,MAAc,EAAE,IAAY;IAC7C,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,WAAW,EAAE,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;AAChG,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,MAAgB;IAC9C,OAAO,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAChE,6EAA6E;QAC7E,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;YAChC,IAAI,EAAE,CAAC;YACP,OAAO;QACR,CAAC;QAED,mCAAmC;QACnC,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACpC,IAAI,EAAE,CAAC;YACP,OAAO;QACR,CAAC;QAED,MAAM,UAAU,GAAG,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC;QAC7C,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;YACxC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,yCAAyC,EAAE,CAAC,CAAC;YAC3E,OAAO;QACR,CAAC;QAED,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAElC,IAAI,CAAC;YACJ,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE;gBAC5C,UAAU,EAAE,CAAC,OAAO,CAAC;aACrB,CAAC,CAAC;YACH,IAAI,EAAE,CAAC;QACR,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACd,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,EAAE,yBAAyB,CAAC,CAAC;YACnD,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,0BAA0B,EAAE,CAAC,CAAC;QAC7D,CAAC;IACF,CAAC,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,MAAgB,EAAE,KAAoB;IACnE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QAChC,OAAO,IAAI,CAAC,CAAC,6BAA6B;IAC3C,CAAC;IAED,IAAI,CAAC,KAAK,EAAE,CAAC;QACZ,OAAO,KAAK,CAAC;IACd,CAAC;IAED,IAAI,CAAC;QACJ,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QACxE,OAAO,IAAI,CAAC;IACb,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,KAAK,CAAC;IACd,CAAC;AACF,CAAC"}

package/dist/api/notifications.d.ts

@@ -0,0 +1,14 @@
+import type { WebSocket } from 'ws';
+/**
+ * Register a WebSocket client for event notifications.
+ */
+export declare function subscribeClient(connectionId: string, ws: WebSocket): void;
+/**
+ * Unregister a WebSocket client.
+ */
+export declare function unsubscribeClient(connectionId: string): void;
+/**
+ * Initialize the notification system — subscribes to event bus and broadcasts to clients.
+ */
+export declare function initNotifications(): void;
+//# sourceMappingURL=notifications.d.ts.map

package/dist/api/notifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../../src/api/notifications.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AASpC;;GAEG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,GAAG,IAAI,CAEzE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAE5D;AA8DD;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAkCxC"}