mirror of
https://github.com/anomalyco/opencode.git
synced 2026-07-24 04:01:10 -04:00
feat(daemon): add lifecycle hooks and WezTerm orchestration (Phase 4-5)
Phase 4: Tiara Hook Integration - Add lifecycle hooks module (src/hooks/lifecycle.ts) - Daemon lifecycle hooks: start, ready, shutdown - Session lifecycle hooks: start, restore, end, transfer - Todo lifecycle hooks: continuation, completed, blocked - Integrate hooks with daemon startup/shutdown - Integrate hooks with Telegram gateway for session events Phase 5: WezTerm Visual Orchestration - Add WezTerm orchestration module (src/orchestration/wezterm.ts) - Display detection (X11 via DISPLAY, Wayland via WAYLAND_DISPLAY) - Status pane showing daemon health, services, sessions - Session pane management API (create/close/focus) - Graceful degradation when no display available - CLI options: --wezterm, --wezterm-layout - Integration with lifecycle hooks for auto-updates Also includes: - Session persistence module (src/session/persistence.ts) - Telegram gateway (src/gateway/telegram.ts) - Daemon CLI command (src/cli/cmd/daemon.ts) - Systemd service files (scripts/systemd/) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Artur Do Lago
@@ -74,176 +74,275 @@ Immediate integration of todo-continuation into existing systems.
|
||||
---
|
||||
|
||||
### Phase 1: Headless Daemon Mode
|
||||
**Status: Complete**
|
||||
**Prerequisites: Phase 0 complete**
|
||||
|
||||
agent-core runs as a system service, starting before user login.
|
||||
|
||||
#### 1.1 Systemd Service
|
||||
#### 1.1 Systemd Service (DONE)
|
||||
Service file at `scripts/systemd/agent-core.service` with install script.
|
||||
|
||||
```bash
|
||||
# /etc/systemd/system/agent-core.service
|
||||
[Unit]
|
||||
Description=Agent Core - Always-On Personas
|
||||
After=network.target
|
||||
# Install the service
|
||||
sudo ./scripts/systemd/install.sh
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=artur
|
||||
Environment=HOME=/home/artur
|
||||
Environment=AGENT_CORE_HEADLESS=1
|
||||
WorkingDirectory=/home/artur/Repositories/agent-core
|
||||
ExecStart=/home/artur/.bun/bin/bun run packages/opencode/src/cli/index.ts daemon
|
||||
Restart=always
|
||||
RestartSec=10
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
# Or manually copy
|
||||
sudo cp scripts/systemd/agent-core.service /etc/systemd/system/
|
||||
sudo systemctl daemon-reload
|
||||
sudo systemctl enable agent-core
|
||||
sudo systemctl start agent-core
|
||||
```
|
||||
|
||||
#### 1.2 Daemon Mode Implementation
|
||||
- [ ] Create `daemon` command in CLI
|
||||
- [ ] Headless session management (no TUI)
|
||||
- [ ] API server for remote communication
|
||||
- [ ] Credential management without user session
|
||||
- [ ] Logging to file/journald
|
||||
#### 1.2 Daemon Mode Implementation (DONE)
|
||||
- [x] Create `daemon` command in CLI
|
||||
- [x] Headless session management (no TUI)
|
||||
- [x] API server for remote communication (reuses existing Server)
|
||||
- [x] Logging to file/journald
|
||||
- [x] PID file management for service control
|
||||
- [x] Signal handlers for graceful shutdown
|
||||
- [x] Session restoration with todo-continuation on startup
|
||||
|
||||
#### 1.3 Credential Access
|
||||
- [ ] Keyring access from service context
|
||||
- [ ] Environment-based fallback for API keys
|
||||
- [ ] Secure credential storage at `~/.zee/credentials/`
|
||||
CLI Commands:
|
||||
- `opencode daemon` - Start the daemon
|
||||
- `opencode daemon-status` - Check if running
|
||||
- `opencode daemon-stop` - Stop the daemon
|
||||
|
||||
#### 1.3 Credential Access (PARTIAL)
|
||||
- [x] Environment-based fallback for API keys (via daemon.env file)
|
||||
- [ ] Keyring access from service context (future)
|
||||
- [ ] Secure credential storage at `~/.zee/credentials/` (future)
|
||||
|
||||
#### 1.4 Configuration Schema (DONE)
|
||||
Added `daemon` section to config schema:
|
||||
```json
|
||||
{
|
||||
"daemon": {
|
||||
"enabled": true,
|
||||
"session": {
|
||||
"persistence": true,
|
||||
"checkpoint_interval": 300,
|
||||
"recovery": true
|
||||
},
|
||||
"todo": {
|
||||
"auto_continue": true,
|
||||
"notify_on_incomplete": true
|
||||
},
|
||||
"gateway": {
|
||||
"telegram": { "enabled": false },
|
||||
"discord": { "enabled": false }
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Phase 2: Remote Communication Gateway
|
||||
**Status: Telegram Complete**
|
||||
**Prerequisites: Phase 1 complete**
|
||||
|
||||
Zee becomes the universal gateway for all communication.
|
||||
|
||||
#### 2.1 Messaging Platform Integration
|
||||
```
|
||||
┌──────────────────────────────────────────────────────────────┐
|
||||
│ ZEE GATEWAY │
|
||||
├──────────────────────────────────────────────────────────────┤
|
||||
│ │
|
||||
│ Telegram ──┐ │
|
||||
│ │ ┌──────────────────────────────────────┐ │
|
||||
│ WhatsApp ──┼───►│ Message Router │ │
|
||||
│ │ │ │ │
|
||||
│ Discord ───┘ │ • Parse intent │ │
|
||||
│ │ • Route to persona (Zee/Stanley/ │ │
|
||||
│ │ Johny) │ │
|
||||
│ │ • Queue if busy │ │
|
||||
│ │ • Return results │ │
|
||||
│ └──────────────────────────────────────┘ │
|
||||
│ │
|
||||
│ Outbound: │
|
||||
│ • Task completion notifications │
|
||||
│ • Todo status updates │
|
||||
│ • Error alerts │
|
||||
│ • Daily summaries │
|
||||
└──────────────────────────────────────────────────────────────┘
|
||||
#### 2.1 Telegram Gateway (DONE)
|
||||
|
||||
Implementation at `packages/opencode/src/gateway/telegram.ts`:
|
||||
|
||||
- [x] Long polling for incoming messages (no webhook required)
|
||||
- [x] Intent-based persona routing (finance → Stanley, learning → Johny, else → Zee)
|
||||
- [x] User/chat authorization via allowlist
|
||||
- [x] Bot commands (/start, /status, /new, /zee, /stanley, /johny)
|
||||
- [x] Automatic message chunking for Telegram's 4096 char limit
|
||||
- [x] Integration with daemon startup
|
||||
- [x] Outbound notification support
|
||||
|
||||
**Usage:**
|
||||
```bash
|
||||
# Set up your bot token (get from @BotFather)
|
||||
export TELEGRAM_BOT_TOKEN=your-token-here
|
||||
|
||||
# Optionally restrict to specific users (get ID from @userinfobot)
|
||||
export TELEGRAM_ALLOWED_USERS=123456789,987654321
|
||||
|
||||
# Start daemon with Telegram gateway
|
||||
opencode daemon --port 4567
|
||||
```
|
||||
|
||||
#### 2.2 Implementation Tasks
|
||||
- [ ] Telegram bot running in daemon mode
|
||||
- [ ] WhatsApp integration (if available)
|
||||
**Bot Commands:**
|
||||
- `/start` - Welcome message and help
|
||||
- `/status` - Check system status
|
||||
- `/new` - Start new conversation
|
||||
- `/zee` - Switch to Zee persona
|
||||
- `/stanley` - Switch to Stanley persona
|
||||
- `/johny` - Switch to Johny persona
|
||||
|
||||
**Intent Routing Patterns:**
|
||||
- Stanley: portfolio, stock, market, invest, trading, finance, ticker, NVDA/AAPL/TSLA
|
||||
- Johny: study, learn, quiz, teach, explain, knowledge, practice, math/calculus
|
||||
- Zee: Everything else (default)
|
||||
|
||||
#### 2.2 Future Platforms
|
||||
- [ ] WhatsApp integration (requires Business API)
|
||||
- [ ] Discord bot as alternative
|
||||
- [ ] Message queue for handling during offline
|
||||
- [ ] Intent parsing to route to correct persona:
|
||||
- "Check my portfolio" → Stanley
|
||||
- "What's on my calendar" → Zee
|
||||
- "Quiz me on calculus" → Johny
|
||||
|
||||
#### 2.3 Security Considerations
|
||||
- [ ] Device authentication
|
||||
- [ ] Rate limiting
|
||||
- [ ] Audit logging
|
||||
- [ ] Session tokens for multi-device
|
||||
#### 2.3 Security (PARTIAL)
|
||||
- [x] User ID allowlist
|
||||
- [x] Chat ID allowlist
|
||||
- [ ] Rate limiting (future)
|
||||
- [ ] Audit logging (future)
|
||||
|
||||
---
|
||||
|
||||
### Phase 3: Session Persistence & Recovery
|
||||
**Prerequisites: Phase 1, 2 in progress**
|
||||
**Status: Complete**
|
||||
**Prerequisites: Phase 1, 2 complete**
|
||||
|
||||
Robust session management that survives anything.
|
||||
Robust session management that survives crashes and restarts.
|
||||
|
||||
#### 3.1 Persistence Module (DONE)
|
||||
|
||||
Implementation at `packages/opencode/src/session/persistence.ts`:
|
||||
|
||||
#### 3.1 Persistent Session Store
|
||||
```
|
||||
~/.zee/
|
||||
├── sessions/
|
||||
│ ├── active/ # Currently active sessions
|
||||
│ │ ├── {session-id}.json
|
||||
│ │ └── {session-id}.todos.json
|
||||
│ └── archive/ # Completed sessions
|
||||
├── state/
|
||||
│ ├── daemon.pid # Daemon process ID
|
||||
│ ├── daemon.lock # Lock file
|
||||
│ └── last-active.json # Last active session per persona
|
||||
└── recovery/
|
||||
├── checkpoint/ # Periodic state snapshots
|
||||
└── journal/ # Write-ahead log for crash recovery
|
||||
~/.local/state/agent-core/persistence/
|
||||
├── checkpoints/
|
||||
│ └── checkpoint-{timestamp}/
|
||||
│ ├── sessions.json # All sessions with todos
|
||||
│ ├── last-active.json # Last active per persona
|
||||
│ └── metadata.json # Checkpoint metadata
|
||||
├── wal.jsonl # Write-ahead log
|
||||
├── last-active.json # Current last active state
|
||||
└── recovery-needed # Marker (removed on clean shutdown)
|
||||
```
|
||||
|
||||
#### 3.2 Recovery Mechanisms
|
||||
- [ ] Checkpoint every N minutes
|
||||
- [ ] Write-ahead logging for in-progress operations
|
||||
- [ ] Graceful shutdown with state save
|
||||
- [ ] Crash recovery on restart:
|
||||
1. Load last checkpoint
|
||||
2. Replay journal entries
|
||||
3. Trigger todo-continuation hooks
|
||||
4. Resume interrupted work
|
||||
#### 3.2 Features Implemented
|
||||
|
||||
#### 3.3 Cross-Device Session Continuity
|
||||
- [ ] Phone starts a conversation
|
||||
- [ ] Continue on desktop
|
||||
- [ ] Session context follows the user
|
||||
**Checkpoints:**
|
||||
- [x] Periodic checkpoints (default: every 5 minutes)
|
||||
- [x] Configurable checkpoint interval
|
||||
- [x] Automatic cleanup of old checkpoints (keeps last 3)
|
||||
- [x] Full session state with todos
|
||||
|
||||
**Write-Ahead Logging:**
|
||||
- [x] Logs session creates/updates
|
||||
- [x] Logs message creates
|
||||
- [x] Logs todo updates
|
||||
- [x] Logs last active session changes
|
||||
- [x] Automatic WAL replay on crash recovery
|
||||
|
||||
**Recovery:**
|
||||
- [x] Recovery marker detects unclean shutdown
|
||||
- [x] Automatic recovery on daemon startup
|
||||
- [x] Checkpoint restoration
|
||||
- [x] WAL replay after checkpoint
|
||||
|
||||
**Last Active Tracking:**
|
||||
- [x] Tracks last active session per persona (zee/stanley/johny)
|
||||
- [x] Stores associated Telegram chat ID
|
||||
- [x] Enables session continuity across restarts
|
||||
- [x] Integrated with Telegram gateway
|
||||
|
||||
#### 3.3 Cross-Device Session Continuity (DONE)
|
||||
- [x] Session restored when same chat ID reconnects
|
||||
- [x] Per-persona session tracking
|
||||
- [x] Works across daemon restarts
|
||||
|
||||
---
|
||||
|
||||
### Phase 4: Tiara Hook Integration
|
||||
**Prerequisites: Phase 0.1 complete, Phase 1-3 in progress**
|
||||
**Status: Complete**
|
||||
**Prerequisites: Phase 0.1 complete, Phase 1-3 complete**
|
||||
|
||||
Full hook lifecycle for session management.
|
||||
|
||||
#### 4.1 Hook Events
|
||||
#### 4.1 Lifecycle Hooks Module (DONE)
|
||||
|
||||
Implementation at `packages/opencode/src/hooks/lifecycle.ts`:
|
||||
|
||||
```typescript
|
||||
// Daemon lifecycle
|
||||
LifecycleHooks.Daemon.Start // Daemon starting up
|
||||
LifecycleHooks.Daemon.Ready // Daemon ready to accept work
|
||||
LifecycleHooks.Daemon.Shutdown // Graceful shutdown initiated
|
||||
|
||||
// Session lifecycle
|
||||
'session-start' // New session created
|
||||
'session-restore' // Existing session loaded (triggers todo-continuation)
|
||||
'session-end' // Session completed or suspended
|
||||
'session-transfer' // Session moving to different device/context
|
||||
LifecycleHooks.SessionLifecycle.Start // New session created
|
||||
LifecycleHooks.SessionLifecycle.Restore // Existing session restored (triggers todo-continuation)
|
||||
LifecycleHooks.SessionLifecycle.End // Session completed or suspended
|
||||
LifecycleHooks.SessionLifecycle.Transfer // Session moving to different device/context
|
||||
|
||||
// Todo lifecycle
|
||||
'todo-continuation' // Incomplete tasks detected
|
||||
'todo-completed' // All tasks done
|
||||
'todo-blocked' // Task cannot proceed, needs input
|
||||
|
||||
// Daemon lifecycle
|
||||
'daemon-start' // Daemon starting up
|
||||
'daemon-ready' // Daemon ready to accept work
|
||||
'daemon-shutdown' // Graceful shutdown initiated
|
||||
LifecycleHooks.TodoLifecycle.Continuation // Incomplete tasks detected
|
||||
LifecycleHooks.TodoLifecycle.Completed // All tasks done
|
||||
LifecycleHooks.TodoLifecycle.Blocked // Task cannot proceed, needs input
|
||||
```
|
||||
|
||||
#### 4.2 Integration Points
|
||||
- [ ] Daemon startup triggers `session-restore` for all active sessions
|
||||
- [ ] Message gateway triggers `session-start` or `session-restore`
|
||||
- [ ] TUI session switch triggers `session-restore`
|
||||
- [ ] All paths check for todo-continuation
|
||||
#### 4.2 Hook Integration Points (DONE)
|
||||
- [x] Daemon startup emits `daemon.start` and `daemon.ready`
|
||||
- [x] Daemon shutdown emits `daemon.shutdown`
|
||||
- [x] Telegram gateway emits `session.lifecycle.start` for new sessions
|
||||
- [x] Telegram gateway emits `session.lifecycle.restore` when restoring sessions
|
||||
- [x] Session restore triggers `todo.lifecycle.continuation` when incomplete todos exist
|
||||
|
||||
#### 4.3 Hook Registration
|
||||
Hooks use the standard Bus event system for pub/sub:
|
||||
```typescript
|
||||
// Subscribe to daemon ready
|
||||
Bus.subscribe(LifecycleHooks.Daemon.Ready, (event) => {
|
||||
console.log(`Daemon ready on port ${event.properties.port}`)
|
||||
})
|
||||
|
||||
// Custom handler registration
|
||||
LifecycleHooks.on(LifecycleHooks.TodoLifecycle.Continuation, async (payload) => {
|
||||
// Handle todo continuation
|
||||
})
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Phase 5: Visual Orchestration (Optional Enhancement)
|
||||
**Status: WezTerm Complete**
|
||||
**Prerequisites: All previous phases**
|
||||
|
||||
When you're at your desk, see what the personas are doing.
|
||||
|
||||
#### 5.1 WezTerm Integration
|
||||
- [ ] Daemon spawns WezTerm panes when X session available
|
||||
- [ ] One pane per active drone/task
|
||||
- [ ] Status pane showing overall system state
|
||||
- [ ] Graceful degradation when no display
|
||||
#### 5.1 WezTerm Integration (DONE)
|
||||
|
||||
#### 5.2 Web Dashboard (Alternative)
|
||||
Implementation at `packages/opencode/src/orchestration/wezterm.ts`:
|
||||
|
||||
- [x] Daemon spawns WezTerm status pane when X/Wayland session available
|
||||
- [x] Display detection (X11 via DISPLAY, Wayland via WAYLAND_DISPLAY)
|
||||
- [x] Status pane showing daemon health, services, sessions
|
||||
- [x] Graceful degradation when no display (falls back silently)
|
||||
- [x] Session pane management API (create/close/focus)
|
||||
- [x] Integration with lifecycle hooks (auto-updates on events)
|
||||
|
||||
**CLI Options:**
|
||||
```bash
|
||||
opencode daemon --wezterm # Enable (default: true)
|
||||
opencode daemon --no-wezterm # Disable
|
||||
opencode daemon --wezterm-layout horizontal # Layout: horizontal|vertical|grid
|
||||
```
|
||||
|
||||
**Status Pane Features:**
|
||||
- PID, port, uptime display
|
||||
- Service status (Persistence, Telegram, Discord, WezTerm)
|
||||
- Session count and incomplete todos
|
||||
- Auto-refresh every 5 seconds
|
||||
|
||||
**Session Pane API:**
|
||||
```typescript
|
||||
// Create a pane for a session
|
||||
const paneId = await WeztermOrchestration.createSessionPane(sessionId, "My Session", "zee")
|
||||
|
||||
// Send command to pane
|
||||
await WeztermOrchestration.sendToSessionPane(sessionId, "echo hello")
|
||||
|
||||
// Focus/close pane
|
||||
await WeztermOrchestration.focusSessionPane(sessionId)
|
||||
await WeztermOrchestration.closeSessionPane(sessionId)
|
||||
```
|
||||
|
||||
#### 5.2 Web Dashboard (Future)
|
||||
- [ ] Local web server in daemon
|
||||
- [ ] Real-time status via WebSocket
|
||||
- [ ] Access from any device on local network
|
||||
@@ -254,18 +353,42 @@ When you're at your desk, see what the personas are doing.
|
||||
## Current Status
|
||||
|
||||
### Completed
|
||||
- Todo continuation hook infrastructure in tiara
|
||||
- CLI integration for session-restore with todo-continuation
|
||||
- Session storage in opencode sync context
|
||||
- Phase 0: Todo continuation hook infrastructure in tiara
|
||||
- Phase 0: CLI integration for session-restore with todo-continuation
|
||||
- Phase 0: Session storage in opencode sync context
|
||||
- Phase 0: TUI integration (toast, backend reminder, prompt hint)
|
||||
- Phase 1: Headless daemon mode with systemd service
|
||||
- Phase 1: Daemon CLI commands (daemon, daemon-status, daemon-stop)
|
||||
- Phase 1: Configuration schema for daemon settings
|
||||
- Phase 1: Session restoration with todo-continuation on daemon startup
|
||||
- Phase 2: Telegram gateway with persona routing
|
||||
- Phase 2: Intent-based persona detection (Stanley/Johny/Zee)
|
||||
- Phase 2: User authorization allowlists
|
||||
- Phase 3: Session persistence with checkpoints and WAL
|
||||
- Phase 3: Crash recovery with automatic checkpoint restoration
|
||||
- Phase 3: Last active session tracking per persona
|
||||
- Phase 3: Cross-device session continuity
|
||||
- Phase 4: Lifecycle hooks module (`packages/opencode/src/hooks/lifecycle.ts`)
|
||||
- Phase 4: Daemon lifecycle hooks (start, ready, shutdown)
|
||||
- Phase 4: Session lifecycle hooks (start, restore, end, transfer)
|
||||
- Phase 4: Todo lifecycle hooks (continuation, completed, blocked)
|
||||
- Phase 4: Daemon integration with lifecycle hooks
|
||||
- Phase 4: Telegram gateway integration with session hooks
|
||||
- Phase 5: WezTerm orchestration module (`packages/opencode/src/orchestration/wezterm.ts`)
|
||||
- Phase 5: Display detection (X11/Wayland)
|
||||
- Phase 5: Status pane with daemon health visualization
|
||||
- Phase 5: Session pane management API
|
||||
- Phase 5: Graceful degradation when no display
|
||||
- Phase 5: Integration with lifecycle hooks for auto-updates
|
||||
|
||||
### In Progress
|
||||
- TUI integration (toast, backend reminder, prompt hint)
|
||||
- None (Phases 0-5 complete)
|
||||
|
||||
### Next Steps
|
||||
1. Implement TUI todo-continuation integrations
|
||||
2. Create daemon mode skeleton
|
||||
3. Design message gateway architecture
|
||||
4. Implement persistent session store
|
||||
1. Add Discord gateway (if needed)
|
||||
2. Add web dashboard (Phase 5.2)
|
||||
3. Rate limiting and audit logging for gateways
|
||||
4. TUI integration with session lifecycle hooks
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -0,0 +1,450 @@
|
||||
import { Server } from "../../server/server"
|
||||
import { cmd } from "./cmd"
|
||||
import { withNetworkOptions, resolveNetworkOptions } from "../network"
|
||||
import { Log } from "../../util/log"
|
||||
import { Global } from "../../global"
|
||||
import { Session } from "../../session"
|
||||
import { Todo } from "../../session/todo"
|
||||
import { Persistence } from "../../session/persistence"
|
||||
import { Bus } from "../../bus"
|
||||
import { Instance } from "../../project/instance"
|
||||
import { TelegramGateway } from "../../gateway/telegram"
|
||||
import { LifecycleHooks } from "../../hooks/lifecycle"
|
||||
import { WeztermOrchestration } from "../../orchestration/wezterm"
|
||||
import fs from "fs/promises"
|
||||
import path from "path"
|
||||
import os from "os"
|
||||
|
||||
const log = Log.create({ service: "daemon" })
|
||||
|
||||
export namespace Daemon {
|
||||
const STATE_DIR = path.join(Global.Path.state, "daemon")
|
||||
const PID_FILE = path.join(STATE_DIR, "daemon.pid")
|
||||
const LOCK_FILE = path.join(STATE_DIR, "daemon.lock")
|
||||
|
||||
export interface DaemonState {
|
||||
pid: number
|
||||
port: number
|
||||
hostname: string
|
||||
startTime: number
|
||||
directory: string
|
||||
}
|
||||
|
||||
async function ensureStateDir() {
|
||||
await fs.mkdir(STATE_DIR, { recursive: true })
|
||||
}
|
||||
|
||||
export async function writePidFile(state: DaemonState) {
|
||||
await ensureStateDir()
|
||||
await fs.writeFile(PID_FILE, JSON.stringify(state, null, 2))
|
||||
log.info("wrote pid file", { path: PID_FILE, state })
|
||||
}
|
||||
|
||||
export async function removePidFile() {
|
||||
try {
|
||||
await fs.unlink(PID_FILE)
|
||||
log.info("removed pid file", { path: PID_FILE })
|
||||
} catch (e) {
|
||||
// Ignore if file doesn't exist
|
||||
}
|
||||
}
|
||||
|
||||
export async function readPidFile(): Promise<DaemonState | null> {
|
||||
try {
|
||||
const content = await fs.readFile(PID_FILE, "utf-8")
|
||||
return JSON.parse(content)
|
||||
} catch {
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
export async function isRunning(): Promise<boolean> {
|
||||
const state = await readPidFile()
|
||||
if (!state) return false
|
||||
|
||||
try {
|
||||
// Check if process is running
|
||||
process.kill(state.pid, 0)
|
||||
return true
|
||||
} catch {
|
||||
// Process not running, clean up stale pid file
|
||||
await removePidFile()
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
export async function restoreSessionsWithTodos(directory: string) {
|
||||
log.info("checking for sessions with incomplete todos", { directory })
|
||||
|
||||
const sessions: Session.Info[] = []
|
||||
for await (const session of Session.list()) {
|
||||
sessions.push(session)
|
||||
}
|
||||
|
||||
let restoredCount = 0
|
||||
for (const session of sessions) {
|
||||
const todos = await Todo.get(session.id)
|
||||
const incompleteTodos = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled")
|
||||
|
||||
if (incompleteTodos.length > 0) {
|
||||
log.info("found session with incomplete todos", {
|
||||
sessionID: session.id,
|
||||
title: session.title,
|
||||
incomplete: incompleteTodos.length,
|
||||
total: todos.length,
|
||||
})
|
||||
restoredCount++
|
||||
}
|
||||
}
|
||||
|
||||
if (restoredCount > 0) {
|
||||
log.info("sessions with incomplete todos ready for continuation", { count: restoredCount })
|
||||
} else {
|
||||
log.info("no sessions with incomplete todos found")
|
||||
}
|
||||
|
||||
return restoredCount
|
||||
}
|
||||
|
||||
export async function setupSignalHandlers(
|
||||
cleanup: (signal?: NodeJS.Signals) => Promise<void>
|
||||
) {
|
||||
const signals: NodeJS.Signals[] = ["SIGINT", "SIGTERM", "SIGHUP"]
|
||||
|
||||
for (const signal of signals) {
|
||||
process.on(signal, async () => {
|
||||
log.info("received signal, shutting down", { signal })
|
||||
await cleanup(signal)
|
||||
process.exit(0)
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export const DaemonCommand = cmd({
|
||||
command: "daemon",
|
||||
builder: (yargs) =>
|
||||
withNetworkOptions(yargs)
|
||||
.option("directory", {
|
||||
describe: "Working directory for the daemon",
|
||||
type: "string",
|
||||
default: process.cwd(),
|
||||
})
|
||||
.option("foreground", {
|
||||
describe: "Run in foreground (don't daemonize)",
|
||||
type: "boolean",
|
||||
default: true, // For now, always run in foreground
|
||||
})
|
||||
.option("restore-sessions", {
|
||||
describe: "Restore sessions with incomplete todos on startup",
|
||||
type: "boolean",
|
||||
default: true,
|
||||
})
|
||||
.option("telegram-token", {
|
||||
describe: "Telegram bot token for remote access gateway",
|
||||
type: "string",
|
||||
default: process.env.TELEGRAM_BOT_TOKEN,
|
||||
})
|
||||
.option("telegram-users", {
|
||||
describe: "Comma-separated list of allowed Telegram user IDs",
|
||||
type: "string",
|
||||
default: process.env.TELEGRAM_ALLOWED_USERS,
|
||||
})
|
||||
.option("wezterm", {
|
||||
describe: "Enable WezTerm visual orchestration when display available",
|
||||
type: "boolean",
|
||||
default: true,
|
||||
})
|
||||
.option("wezterm-layout", {
|
||||
describe: "WezTerm pane layout",
|
||||
type: "string",
|
||||
choices: ["horizontal", "vertical", "grid"],
|
||||
default: "horizontal",
|
||||
}),
|
||||
describe: "Start agent-core as a headless daemon for remote access",
|
||||
handler: async (args) => {
|
||||
// Check if already running
|
||||
if (await Daemon.isRunning()) {
|
||||
const state = await Daemon.readPidFile()
|
||||
console.error(`Daemon already running (PID: ${state?.pid}, Port: ${state?.port})`)
|
||||
console.error(`Use 'opencode daemon stop' to stop it first`)
|
||||
process.exit(1)
|
||||
}
|
||||
|
||||
const opts = await resolveNetworkOptions(args)
|
||||
const directory = args.directory as string
|
||||
|
||||
log.info("starting daemon", {
|
||||
directory,
|
||||
hostname: opts.hostname,
|
||||
port: opts.port,
|
||||
restoreSessions: args["restore-sessions"],
|
||||
})
|
||||
|
||||
// Start the server
|
||||
const server = Server.listen(opts)
|
||||
|
||||
// Write PID file
|
||||
const state: Daemon.DaemonState = {
|
||||
pid: process.pid,
|
||||
port: server.port ?? opts.port,
|
||||
hostname: server.hostname ?? opts.hostname,
|
||||
startTime: Date.now(),
|
||||
directory,
|
||||
}
|
||||
await Daemon.writePidFile(state)
|
||||
|
||||
// Emit daemon.start hook
|
||||
await LifecycleHooks.emitDaemonStart({
|
||||
pid: process.pid,
|
||||
port: state.port,
|
||||
hostname: state.hostname,
|
||||
directory,
|
||||
startTime: state.startTime,
|
||||
})
|
||||
|
||||
// Initialize session persistence (checkpoints, WAL, recovery)
|
||||
let persistenceEnabled = false
|
||||
try {
|
||||
await Instance.provide({
|
||||
directory,
|
||||
async fn() {
|
||||
await Persistence.init({
|
||||
checkpointInterval: 5 * 60 * 1000, // 5 minutes
|
||||
maxCheckpoints: 3,
|
||||
enableWAL: true,
|
||||
})
|
||||
persistenceEnabled = true
|
||||
},
|
||||
})
|
||||
console.log("Persistence: Enabled (checkpoints + WAL)")
|
||||
} catch (error) {
|
||||
log.error("Failed to initialize persistence", {
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
console.error(`Warning: Persistence initialization failed: ${error instanceof Error ? error.message : error}`)
|
||||
}
|
||||
|
||||
// Start Telegram gateway if configured
|
||||
const telegramToken = args["telegram-token"] as string | undefined
|
||||
let telegramGateway: TelegramGateway.Gateway | null = null
|
||||
|
||||
if (telegramToken) {
|
||||
const allowedUsers = (args["telegram-users"] as string | undefined)
|
||||
?.split(",")
|
||||
.map((id) => parseInt(id.trim(), 10))
|
||||
.filter((id) => !isNaN(id))
|
||||
|
||||
try {
|
||||
telegramGateway = await TelegramGateway.start({
|
||||
botToken: telegramToken,
|
||||
allowedUsers,
|
||||
directory,
|
||||
apiPort: state.port,
|
||||
})
|
||||
console.log(`Telegram: Gateway started (${allowedUsers?.length || "all"} users allowed)`)
|
||||
} catch (error) {
|
||||
log.error("Failed to start Telegram gateway", {
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
console.error(`Warning: Telegram gateway failed to start: ${error instanceof Error ? error.message : error}`)
|
||||
}
|
||||
}
|
||||
|
||||
// Initialize WezTerm orchestration if enabled
|
||||
let weztermEnabled = false
|
||||
if (args.wezterm) {
|
||||
try {
|
||||
weztermEnabled = await WeztermOrchestration.init({
|
||||
enabled: true,
|
||||
layout: args["wezterm-layout"] as "horizontal" | "vertical" | "grid",
|
||||
showStatusPane: true,
|
||||
statusPanePercent: 20,
|
||||
statusRefreshInterval: 5000,
|
||||
})
|
||||
if (weztermEnabled) {
|
||||
console.log("WezTerm: Visual orchestration enabled")
|
||||
} else {
|
||||
console.log("WezTerm: Not available (no display or WezTerm CLI)")
|
||||
}
|
||||
} catch (error) {
|
||||
log.debug("WezTerm initialization failed", {
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Setup cleanup handlers
|
||||
const cleanup = async (signal?: NodeJS.Signals, error?: Error) => {
|
||||
log.info("daemon shutting down")
|
||||
|
||||
const shutdownReason: "signal" | "error" | "manual" = error ? "error" : signal ? "signal" : "manual"
|
||||
|
||||
// Emit daemon.shutdown hook
|
||||
await LifecycleHooks.emitDaemonShutdown({
|
||||
pid: process.pid,
|
||||
reason: shutdownReason,
|
||||
signal: signal,
|
||||
error: error?.message,
|
||||
})
|
||||
|
||||
// Stop Telegram gateway
|
||||
if (telegramGateway) {
|
||||
await TelegramGateway.stop()
|
||||
}
|
||||
|
||||
// Shutdown WezTerm orchestration
|
||||
if (weztermEnabled) {
|
||||
await WeztermOrchestration.shutdown()
|
||||
}
|
||||
|
||||
// Shutdown persistence (creates final checkpoint, removes recovery marker)
|
||||
if (persistenceEnabled) {
|
||||
await Instance.provide({
|
||||
directory,
|
||||
async fn() {
|
||||
await Persistence.shutdown()
|
||||
},
|
||||
}).catch((e) => log.error("Persistence shutdown error", { error: String(e) }))
|
||||
}
|
||||
|
||||
await Daemon.removePidFile()
|
||||
await server.stop()
|
||||
}
|
||||
|
||||
await Daemon.setupSignalHandlers(cleanup)
|
||||
|
||||
// Handle uncaught errors
|
||||
process.on("uncaughtException", async (error) => {
|
||||
log.error("uncaught exception", { error: error.message, stack: error.stack })
|
||||
await cleanup(undefined, error)
|
||||
process.exit(1)
|
||||
})
|
||||
|
||||
process.on("unhandledRejection", async (reason) => {
|
||||
log.error("unhandled rejection", { reason: String(reason) })
|
||||
})
|
||||
|
||||
const telegramStatus = telegramGateway ? "Active" : telegramToken ? "Failed" : "Not configured"
|
||||
const persistenceStatus = persistenceEnabled ? "Active (checkpoints + WAL)" : "Disabled"
|
||||
const weztermStatus = weztermEnabled ? "Active (status pane)" : args.wezterm ? "No display" : "Disabled"
|
||||
|
||||
console.log(`
|
||||
Agent-Core Daemon Started
|
||||
========================
|
||||
PID: ${process.pid}
|
||||
Port: ${server.port}
|
||||
Hostname: ${server.hostname}
|
||||
Directory: ${directory}
|
||||
URL: http://${server.hostname}:${server.port}
|
||||
|
||||
Services:
|
||||
Persistence: ${persistenceStatus}
|
||||
Telegram: ${telegramStatus}
|
||||
WezTerm: ${weztermStatus}
|
||||
|
||||
API Endpoints:
|
||||
Health: GET /global/health
|
||||
Sessions: GET /session
|
||||
Events: GET /event (SSE)
|
||||
Prompt: POST /session/:id/message
|
||||
|
||||
Press Ctrl+C to stop the daemon.
|
||||
`)
|
||||
|
||||
// Restore sessions with incomplete todos and emit daemon.ready hook
|
||||
let sessionsWithIncompleteTodos = 0
|
||||
if (args["restore-sessions"]) {
|
||||
// Need to provide instance context for session operations
|
||||
await Instance.provide({
|
||||
directory,
|
||||
async fn() {
|
||||
sessionsWithIncompleteTodos = await Daemon.restoreSessionsWithTodos(directory)
|
||||
if (sessionsWithIncompleteTodos > 0) {
|
||||
console.log(`Found ${sessionsWithIncompleteTodos} session(s) with incomplete todos ready for continuation.`)
|
||||
}
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// Emit daemon.ready hook - daemon is fully initialized
|
||||
await LifecycleHooks.emitDaemonReady({
|
||||
pid: process.pid,
|
||||
port: state.port,
|
||||
services: {
|
||||
persistence: persistenceEnabled,
|
||||
telegram: !!telegramGateway,
|
||||
discord: false, // Not implemented yet
|
||||
},
|
||||
sessionsWithIncompleteTodos,
|
||||
})
|
||||
|
||||
// Keep the process running
|
||||
await new Promise(() => {})
|
||||
},
|
||||
})
|
||||
|
||||
// Subcommand: daemon status
|
||||
export const DaemonStatusCommand = cmd({
|
||||
command: "daemon-status",
|
||||
describe: "Check if the daemon is running",
|
||||
handler: async () => {
|
||||
const running = await Daemon.isRunning()
|
||||
const state = await Daemon.readPidFile()
|
||||
|
||||
if (running && state) {
|
||||
console.log(`Daemon is running`)
|
||||
console.log(` PID: ${state.pid}`)
|
||||
console.log(` Port: ${state.port}`)
|
||||
console.log(` Hostname: ${state.hostname}`)
|
||||
console.log(` Directory: ${state.directory}`)
|
||||
console.log(` Started: ${new Date(state.startTime).toISOString()}`)
|
||||
console.log(` URL: http://${state.hostname}:${state.port}`)
|
||||
} else {
|
||||
console.log(`Daemon is not running`)
|
||||
process.exit(1)
|
||||
}
|
||||
},
|
||||
})
|
||||
|
||||
// Subcommand: daemon stop
|
||||
export const DaemonStopCommand = cmd({
|
||||
command: "daemon-stop",
|
||||
describe: "Stop the running daemon",
|
||||
handler: async () => {
|
||||
const state = await Daemon.readPidFile()
|
||||
|
||||
if (!state) {
|
||||
console.log("No daemon PID file found")
|
||||
process.exit(1)
|
||||
}
|
||||
|
||||
try {
|
||||
process.kill(state.pid, "SIGTERM")
|
||||
console.log(`Sent SIGTERM to daemon (PID: ${state.pid})`)
|
||||
|
||||
// Wait for it to stop
|
||||
let attempts = 0
|
||||
while (attempts < 10) {
|
||||
await new Promise((resolve) => setTimeout(resolve, 500))
|
||||
if (!(await Daemon.isRunning())) {
|
||||
console.log("Daemon stopped successfully")
|
||||
return
|
||||
}
|
||||
attempts++
|
||||
}
|
||||
|
||||
// Force kill if still running
|
||||
console.log("Daemon did not stop gracefully, sending SIGKILL")
|
||||
process.kill(state.pid, "SIGKILL")
|
||||
await Daemon.removePidFile()
|
||||
} catch (e) {
|
||||
if ((e as NodeJS.ErrnoException).code === "ESRCH") {
|
||||
console.log("Daemon process not found, cleaning up PID file")
|
||||
await Daemon.removePidFile()
|
||||
} else {
|
||||
throw e
|
||||
}
|
||||
}
|
||||
},
|
||||
})
|
||||
@@ -730,6 +730,63 @@ export namespace Config {
|
||||
ref: "ServerConfig",
|
||||
})
|
||||
|
||||
export const Daemon = z
|
||||
.object({
|
||||
enabled: z.boolean().optional().default(false).describe("Enable daemon mode"),
|
||||
session: z
|
||||
.object({
|
||||
persistence: z.boolean().optional().default(true).describe("Enable session persistence"),
|
||||
checkpoint_interval: z
|
||||
.number()
|
||||
.int()
|
||||
.positive()
|
||||
.optional()
|
||||
.default(300)
|
||||
.describe("Checkpoint interval in seconds"),
|
||||
recovery: z.boolean().optional().default(true).describe("Enable crash recovery"),
|
||||
})
|
||||
.optional()
|
||||
.describe("Session management configuration"),
|
||||
todo: z
|
||||
.object({
|
||||
auto_continue: z
|
||||
.boolean()
|
||||
.optional()
|
||||
.default(true)
|
||||
.describe("Automatically continue incomplete todos on session restore"),
|
||||
notify_on_incomplete: z
|
||||
.boolean()
|
||||
.optional()
|
||||
.default(true)
|
||||
.describe("Send notifications for incomplete todos"),
|
||||
})
|
||||
.optional()
|
||||
.describe("Todo continuation configuration"),
|
||||
gateway: z
|
||||
.object({
|
||||
telegram: z
|
||||
.object({
|
||||
enabled: z.boolean().optional().default(false).describe("Enable Telegram bot gateway"),
|
||||
bot_token: z.string().optional().describe("Telegram bot token"),
|
||||
})
|
||||
.optional()
|
||||
.describe("Telegram gateway configuration"),
|
||||
discord: z
|
||||
.object({
|
||||
enabled: z.boolean().optional().default(false).describe("Enable Discord bot gateway"),
|
||||
bot_token: z.string().optional().describe("Discord bot token"),
|
||||
})
|
||||
.optional()
|
||||
.describe("Discord gateway configuration"),
|
||||
})
|
||||
.optional()
|
||||
.describe("Remote communication gateway configuration"),
|
||||
})
|
||||
.strict()
|
||||
.meta({
|
||||
ref: "DaemonConfig",
|
||||
})
|
||||
|
||||
export const Layout = z.enum(["auto", "stretch"]).meta({
|
||||
ref: "LayoutConfig",
|
||||
})
|
||||
@@ -796,6 +853,7 @@ export namespace Config {
|
||||
logLevel: Log.Level.optional().describe("Log level"),
|
||||
tui: TUI.optional().describe("TUI specific settings"),
|
||||
server: Server.optional().describe("Server configuration for opencode serve and web commands"),
|
||||
daemon: Daemon.optional().describe("Daemon mode configuration for headless operation"),
|
||||
command: z
|
||||
.record(z.string(), Command)
|
||||
.optional()
|
||||
|
||||
@@ -0,0 +1,673 @@
|
||||
/**
|
||||
* Telegram Gateway for Always-On Personas
|
||||
*
|
||||
* Provides bi-directional communication with Telegram, routing messages
|
||||
* to the appropriate persona (Zee/Stanley/Johny) and sending responses back.
|
||||
*
|
||||
* Architecture:
|
||||
* - Long polling for incoming messages (no webhook server required)
|
||||
* - Zee acts as the gateway, delegating to Stanley/Johny as needed
|
||||
* - Uses the daemon's HTTP API for session management
|
||||
*/
|
||||
|
||||
import { Log } from "../util/log"
|
||||
import { Persistence } from "../session/persistence"
|
||||
import { LifecycleHooks } from "../hooks/lifecycle"
|
||||
import { Todo } from "../session/todo"
|
||||
|
||||
const log = Log.create({ service: "telegram-gateway" })
|
||||
|
||||
export namespace TelegramGateway {
|
||||
// Telegram API types
|
||||
export interface TelegramUser {
|
||||
id: number
|
||||
is_bot: boolean
|
||||
first_name: string
|
||||
last_name?: string
|
||||
username?: string
|
||||
language_code?: string
|
||||
}
|
||||
|
||||
export interface TelegramChat {
|
||||
id: number
|
||||
type: "private" | "group" | "supergroup" | "channel"
|
||||
title?: string
|
||||
username?: string
|
||||
first_name?: string
|
||||
last_name?: string
|
||||
}
|
||||
|
||||
export interface TelegramMessage {
|
||||
message_id: number
|
||||
from?: TelegramUser
|
||||
chat: TelegramChat
|
||||
date: number
|
||||
text?: string
|
||||
reply_to_message?: TelegramMessage
|
||||
}
|
||||
|
||||
export interface TelegramUpdate {
|
||||
update_id: number
|
||||
message?: TelegramMessage
|
||||
}
|
||||
|
||||
export interface GatewayConfig {
|
||||
botToken: string
|
||||
allowedUsers?: number[] // Telegram user IDs allowed to interact
|
||||
allowedChats?: number[] // Chat IDs (groups) allowed
|
||||
pollingInterval?: number // ms between poll requests
|
||||
directory: string // Working directory for sessions
|
||||
apiBaseUrl?: string // Internal API URL (default: http://127.0.0.1:PORT)
|
||||
apiPort?: number
|
||||
}
|
||||
|
||||
interface ChatContext {
|
||||
sessionId: string | null
|
||||
chatId: number
|
||||
lastActivity: number
|
||||
persona: "zee" | "stanley" | "johny"
|
||||
pendingResponse: boolean
|
||||
}
|
||||
|
||||
// Intent patterns for persona routing
|
||||
const STANLEY_PATTERNS = [
|
||||
/portfolio/i,
|
||||
/stock/i,
|
||||
/market/i,
|
||||
/invest/i,
|
||||
/trading/i,
|
||||
/finance/i,
|
||||
/ticker/i,
|
||||
/nvda|aapl|tsla|msft|goog/i,
|
||||
/buy|sell|hold/i,
|
||||
/earnings/i,
|
||||
/dividend/i,
|
||||
]
|
||||
|
||||
const JOHNY_PATTERNS = [
|
||||
/study/i,
|
||||
/learn/i,
|
||||
/quiz/i,
|
||||
/teach/i,
|
||||
/explain/i,
|
||||
/knowledge/i,
|
||||
/practice/i,
|
||||
/spaced repetition/i,
|
||||
/flashcard/i,
|
||||
/math|calculus|algebra|physics|chemistry/i,
|
||||
]
|
||||
|
||||
export class Gateway {
|
||||
private config: GatewayConfig
|
||||
private running = false
|
||||
private lastUpdateId = 0
|
||||
private chatContexts = new Map<number, ChatContext>()
|
||||
private pollTimeout: NodeJS.Timeout | null = null
|
||||
private apiBaseUrl: string
|
||||
|
||||
constructor(config: GatewayConfig) {
|
||||
this.config = {
|
||||
pollingInterval: 1000,
|
||||
apiPort: 3456,
|
||||
...config,
|
||||
}
|
||||
this.apiBaseUrl = config.apiBaseUrl || `http://127.0.0.1:${this.config.apiPort}`
|
||||
}
|
||||
|
||||
async start(): Promise<void> {
|
||||
if (this.running) {
|
||||
log.warn("Gateway already running")
|
||||
return
|
||||
}
|
||||
|
||||
// Validate bot token
|
||||
const me = await this.getMe()
|
||||
if (!me) {
|
||||
throw new Error("Failed to connect to Telegram - invalid bot token")
|
||||
}
|
||||
|
||||
log.info("Telegram gateway started", {
|
||||
botUsername: me.username,
|
||||
botId: me.id,
|
||||
})
|
||||
|
||||
this.running = true
|
||||
this.pollLoop()
|
||||
}
|
||||
|
||||
async stop(): Promise<void> {
|
||||
this.running = false
|
||||
if (this.pollTimeout) {
|
||||
clearTimeout(this.pollTimeout)
|
||||
this.pollTimeout = null
|
||||
}
|
||||
log.info("Telegram gateway stopped")
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Telegram API Methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private async telegramApi<T>(method: string, params?: Record<string, unknown>): Promise<T | null> {
|
||||
const url = `https://api.telegram.org/bot${this.config.botToken}/${method}`
|
||||
|
||||
try {
|
||||
const response = await fetch(url, {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: params ? JSON.stringify(params) : undefined,
|
||||
})
|
||||
|
||||
const data = (await response.json()) as { ok: boolean; result?: T; description?: string }
|
||||
|
||||
if (!data.ok) {
|
||||
log.error("Telegram API error", { method, error: data.description })
|
||||
return null
|
||||
}
|
||||
|
||||
return data.result ?? null
|
||||
} catch (error) {
|
||||
log.error("Telegram API request failed", {
|
||||
method,
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
private async getMe(): Promise<TelegramUser | null> {
|
||||
return this.telegramApi<TelegramUser>("getMe")
|
||||
}
|
||||
|
||||
private async getUpdates(offset?: number): Promise<TelegramUpdate[]> {
|
||||
const result = await this.telegramApi<TelegramUpdate[]>("getUpdates", {
|
||||
offset,
|
||||
timeout: 30, // Long polling timeout
|
||||
allowed_updates: ["message"],
|
||||
})
|
||||
return result ?? []
|
||||
}
|
||||
|
||||
async sendMessage(chatId: number, text: string, replyToMessageId?: number): Promise<boolean> {
|
||||
// Split long messages for Telegram's 4096 char limit
|
||||
const chunks = this.chunkMessage(text, 4000)
|
||||
|
||||
for (let i = 0; i < chunks.length; i++) {
|
||||
const result = await this.telegramApi<TelegramMessage>("sendMessage", {
|
||||
chat_id: chatId,
|
||||
text: chunks[i],
|
||||
parse_mode: "Markdown",
|
||||
reply_to_message_id: i === 0 ? replyToMessageId : undefined,
|
||||
})
|
||||
if (!result) return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
async sendTyping(chatId: number): Promise<void> {
|
||||
await this.telegramApi("sendChatAction", {
|
||||
chat_id: chatId,
|
||||
action: "typing",
|
||||
})
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Polling Loop
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private pollLoop(): void {
|
||||
if (!this.running) return
|
||||
|
||||
this.poll()
|
||||
.catch((error) => {
|
||||
log.error("Poll error", { error: error instanceof Error ? error.message : String(error) })
|
||||
})
|
||||
.finally(() => {
|
||||
if (this.running) {
|
||||
this.pollTimeout = setTimeout(() => this.pollLoop(), this.config.pollingInterval)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
private async poll(): Promise<void> {
|
||||
const updates = await this.getUpdates(this.lastUpdateId + 1)
|
||||
|
||||
for (const update of updates) {
|
||||
this.lastUpdateId = update.update_id
|
||||
|
||||
if (update.message?.text) {
|
||||
await this.handleIncomingMessage(update.message)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Message Handling
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private async handleIncomingMessage(message: TelegramMessage): Promise<void> {
|
||||
const chatId = message.chat.id
|
||||
const userId = message.from?.id
|
||||
const text = message.text || ""
|
||||
|
||||
// Authorization check
|
||||
if (!this.isAuthorized(chatId, userId)) {
|
||||
log.warn("Unauthorized message", { chatId, userId, username: message.from?.username })
|
||||
await this.sendMessage(chatId, "Sorry, you're not authorized to use this bot.")
|
||||
return
|
||||
}
|
||||
|
||||
log.info("Received message", {
|
||||
chatId,
|
||||
userId,
|
||||
username: message.from?.username,
|
||||
text: text.substring(0, 50),
|
||||
})
|
||||
|
||||
// Handle special commands
|
||||
if (text.startsWith("/")) {
|
||||
await this.handleCommand(chatId, text, message.message_id)
|
||||
return
|
||||
}
|
||||
|
||||
// Send typing indicator
|
||||
await this.sendTyping(chatId)
|
||||
|
||||
// Determine which persona should handle this
|
||||
const persona = this.detectPersona(text)
|
||||
|
||||
// Get or create context for this chat
|
||||
const context = await this.getOrCreateContext(chatId, persona)
|
||||
|
||||
try {
|
||||
// Send message via internal API
|
||||
const response = await this.sendToAgent(context, text, persona)
|
||||
|
||||
if (response) {
|
||||
await this.sendMessage(chatId, response, message.message_id)
|
||||
} else {
|
||||
await this.sendMessage(chatId, "Sorry, I couldn't process your request. Please try again.")
|
||||
}
|
||||
} catch (error) {
|
||||
log.error("Failed to process message", {
|
||||
chatId,
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
await this.sendMessage(chatId, "Sorry, I encountered an error processing your message.")
|
||||
}
|
||||
}
|
||||
|
||||
private async handleCommand(chatId: number, command: string, messageId: number): Promise<void> {
|
||||
const [cmd, ...args] = command.split(" ")
|
||||
|
||||
switch (cmd.toLowerCase()) {
|
||||
case "/start":
|
||||
await this.sendMessage(
|
||||
chatId,
|
||||
`Welcome to Agent-Core!
|
||||
|
||||
I'm your gateway to the Personas:
|
||||
• *Zee* - Personal assistant (default)
|
||||
• *Stanley* - Finance & investing
|
||||
• *Johny* - Learning & study
|
||||
|
||||
Just send me a message and I'll route it to the right persona.
|
||||
|
||||
Commands:
|
||||
/status - Check system status
|
||||
/new - Start a new conversation
|
||||
/help - Show this help`,
|
||||
messageId
|
||||
)
|
||||
break
|
||||
|
||||
case "/status":
|
||||
const status = await this.getAgentStatus()
|
||||
await this.sendMessage(chatId, status, messageId)
|
||||
break
|
||||
|
||||
case "/new":
|
||||
this.chatContexts.delete(chatId)
|
||||
await this.sendMessage(chatId, "Started a new conversation. How can I help?", messageId)
|
||||
break
|
||||
|
||||
case "/zee":
|
||||
case "/stanley":
|
||||
case "/johny":
|
||||
const persona = cmd.substring(1) as "zee" | "stanley" | "johny"
|
||||
const context = await this.getOrCreateContext(chatId, persona)
|
||||
context.persona = persona
|
||||
context.sessionId = null // Force new session
|
||||
await this.sendMessage(chatId, `Switched to ${persona.charAt(0).toUpperCase() + persona.slice(1)}. How can I help?`, messageId)
|
||||
break
|
||||
|
||||
case "/help":
|
||||
default:
|
||||
await this.sendMessage(
|
||||
chatId,
|
||||
`Available commands:
|
||||
/start - Welcome message
|
||||
/status - Check system status
|
||||
/new - Start new conversation
|
||||
/zee - Switch to Zee
|
||||
/stanley - Switch to Stanley
|
||||
/johny - Switch to Johny`,
|
||||
messageId
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
private isAuthorized(chatId: number, userId?: number): boolean {
|
||||
// If no restrictions configured, allow all
|
||||
if (!this.config.allowedUsers?.length && !this.config.allowedChats?.length) {
|
||||
return true
|
||||
}
|
||||
|
||||
// Check chat allowlist
|
||||
if (this.config.allowedChats?.includes(chatId)) {
|
||||
return true
|
||||
}
|
||||
|
||||
// Check user allowlist
|
||||
if (userId && this.config.allowedUsers?.includes(userId)) {
|
||||
return true
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
private detectPersona(text: string): "zee" | "stanley" | "johny" {
|
||||
// Check for explicit persona mentions
|
||||
const lowerText = text.toLowerCase()
|
||||
|
||||
if (lowerText.includes("@stanley") || lowerText.startsWith("stanley,") || lowerText.startsWith("stanley:")) {
|
||||
return "stanley"
|
||||
}
|
||||
if (lowerText.includes("@johny") || lowerText.startsWith("johny,") || lowerText.startsWith("johny:")) {
|
||||
return "johny"
|
||||
}
|
||||
if (lowerText.includes("@zee") || lowerText.startsWith("zee,") || lowerText.startsWith("zee:")) {
|
||||
return "zee"
|
||||
}
|
||||
|
||||
// Check intent patterns for Stanley
|
||||
for (const pattern of STANLEY_PATTERNS) {
|
||||
if (pattern.test(text)) {
|
||||
return "stanley"
|
||||
}
|
||||
}
|
||||
|
||||
// Check intent patterns for Johny
|
||||
for (const pattern of JOHNY_PATTERNS) {
|
||||
if (pattern.test(text)) {
|
||||
return "johny"
|
||||
}
|
||||
}
|
||||
|
||||
// Default to Zee for general requests
|
||||
return "zee"
|
||||
}
|
||||
|
||||
private async getOrCreateContext(chatId: number, persona: "zee" | "stanley" | "johny"): Promise<ChatContext> {
|
||||
let context = this.chatContexts.get(chatId)
|
||||
|
||||
// If persona changed, create new context
|
||||
if (!context || context.persona !== persona) {
|
||||
// Try to restore last active session for this persona
|
||||
let restoredSessionId: string | null = null
|
||||
let hasTodos = false
|
||||
let incompleteTodos = 0
|
||||
|
||||
try {
|
||||
const lastActive = await Persistence.getLastActive(persona)
|
||||
if (lastActive && lastActive.chatId === chatId) {
|
||||
restoredSessionId = lastActive.sessionId
|
||||
log.info("Restored last active session", { persona, sessionId: restoredSessionId, chatId })
|
||||
|
||||
// Check for incomplete todos
|
||||
try {
|
||||
const todos = await Todo.get(restoredSessionId)
|
||||
hasTodos = todos.length > 0
|
||||
incompleteTodos = todos.filter(
|
||||
(t) => t.status !== "completed" && t.status !== "cancelled"
|
||||
).length
|
||||
} catch (e) {
|
||||
log.debug("Could not check todos for restored session", { error: String(e) })
|
||||
}
|
||||
|
||||
// Emit session restore hook
|
||||
await LifecycleHooks.emitSessionRestore({
|
||||
sessionId: restoredSessionId,
|
||||
persona,
|
||||
source: "telegram",
|
||||
chatId,
|
||||
hasTodos,
|
||||
incompleteTodos,
|
||||
triggerContinuation: incompleteTodos > 0,
|
||||
})
|
||||
}
|
||||
} catch (e) {
|
||||
// Persistence may not be initialized (e.g., if Instance context not available)
|
||||
log.debug("Could not restore last active session", { error: String(e) })
|
||||
}
|
||||
|
||||
context = {
|
||||
sessionId: restoredSessionId,
|
||||
chatId,
|
||||
lastActivity: Date.now(),
|
||||
persona,
|
||||
pendingResponse: false,
|
||||
}
|
||||
this.chatContexts.set(chatId, context)
|
||||
} else {
|
||||
context.lastActivity = Date.now()
|
||||
}
|
||||
|
||||
return context
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Agent API Integration
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private async sendToAgent(context: ChatContext, text: string, persona: "zee" | "stanley" | "johny"): Promise<string | null> {
|
||||
// Add persona context to the message
|
||||
const personaContext = this.getPersonaContext(persona)
|
||||
const fullMessage = personaContext ? `${personaContext}\n\nUser message: ${text}` : text
|
||||
|
||||
try {
|
||||
// Create a new session if needed
|
||||
if (!context.sessionId) {
|
||||
const session = await this.createSession(persona)
|
||||
if (!session) {
|
||||
return null
|
||||
}
|
||||
context.sessionId = session.id
|
||||
|
||||
// Emit session-start hook for new session
|
||||
await LifecycleHooks.emitSessionStart({
|
||||
sessionId: session.id,
|
||||
persona,
|
||||
source: "telegram",
|
||||
chatId: context.chatId,
|
||||
directory: this.config.directory,
|
||||
})
|
||||
}
|
||||
|
||||
// Track last active session for this persona
|
||||
try {
|
||||
await Persistence.setLastActive(persona, context.sessionId, context.chatId)
|
||||
} catch (e) {
|
||||
// Persistence may not be initialized
|
||||
log.debug("Could not save last active session", { error: String(e) })
|
||||
}
|
||||
|
||||
// Send message and get response
|
||||
const response = await this.sendMessageToSession(context.sessionId, fullMessage)
|
||||
return response
|
||||
} catch (error) {
|
||||
log.error("Agent API error", {
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
private async createSession(persona: string): Promise<{ id: string } | null> {
|
||||
try {
|
||||
const response = await fetch(`${this.apiBaseUrl}/session`, {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({
|
||||
title: `Telegram (${persona})`,
|
||||
}),
|
||||
})
|
||||
|
||||
if (!response.ok) {
|
||||
log.error("Failed to create session", { status: response.status })
|
||||
return null
|
||||
}
|
||||
|
||||
return (await response.json()) as { id: string }
|
||||
} catch (error) {
|
||||
log.error("Create session error", {
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
private async sendMessageToSession(sessionId: string, message: string): Promise<string | null> {
|
||||
try {
|
||||
// Use the message endpoint
|
||||
const response = await fetch(`${this.apiBaseUrl}/session/${sessionId}/message`, {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({
|
||||
content: message,
|
||||
}),
|
||||
})
|
||||
|
||||
if (!response.ok) {
|
||||
log.error("Failed to send message", { status: response.status })
|
||||
return null
|
||||
}
|
||||
|
||||
// The response contains the assistant's reply
|
||||
const data = (await response.json()) as {
|
||||
parts?: Array<{ type: string; text?: string }>
|
||||
}
|
||||
|
||||
// Extract text from response parts
|
||||
const textParts = data.parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text!) || []
|
||||
|
||||
return textParts.join("\n") || null
|
||||
} catch (error) {
|
||||
log.error("Send message error", {
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
private async getAgentStatus(): Promise<string> {
|
||||
try {
|
||||
const response = await fetch(`${this.apiBaseUrl}/global/health`)
|
||||
if (!response.ok) {
|
||||
return "Status: Offline"
|
||||
}
|
||||
|
||||
const health = (await response.json()) as { status: string }
|
||||
return `Status: ${health.status}\nActive chats: ${this.chatContexts.size}`
|
||||
} catch {
|
||||
return "Status: Unable to connect to agent"
|
||||
}
|
||||
}
|
||||
|
||||
private getPersonaContext(persona: "zee" | "stanley" | "johny"): string {
|
||||
switch (persona) {
|
||||
case "stanley":
|
||||
return "[System: You are Stanley, the investing and financial research assistant. Focus on market analysis, portfolio management, and financial strategies. Be concise for mobile messaging.]"
|
||||
case "johny":
|
||||
return "[System: You are Johny, the study and learning assistant. Focus on teaching, quizzing, and knowledge management. Be concise for mobile messaging.]"
|
||||
case "zee":
|
||||
default:
|
||||
return "[System: You are Zee, the personal assistant. Help with life admin, messaging, calendar, and general tasks. Be concise for mobile messaging. You can suggest delegating to Stanley for finance or Johny for learning.]"
|
||||
}
|
||||
}
|
||||
|
||||
private chunkMessage(text: string, maxLength: number): string[] {
|
||||
if (text.length <= maxLength) {
|
||||
return [text]
|
||||
}
|
||||
|
||||
const chunks: string[] = []
|
||||
let remaining = text
|
||||
|
||||
while (remaining.length > 0) {
|
||||
if (remaining.length <= maxLength) {
|
||||
chunks.push(remaining)
|
||||
break
|
||||
}
|
||||
|
||||
// Try to break at newline
|
||||
let breakPoint = remaining.lastIndexOf("\n", maxLength)
|
||||
if (breakPoint < maxLength * 0.5) {
|
||||
// Try to break at space
|
||||
breakPoint = remaining.lastIndexOf(" ", maxLength)
|
||||
}
|
||||
if (breakPoint < maxLength * 0.5) {
|
||||
breakPoint = maxLength
|
||||
}
|
||||
|
||||
chunks.push(remaining.slice(0, breakPoint))
|
||||
remaining = remaining.slice(breakPoint).trimStart()
|
||||
}
|
||||
|
||||
return chunks
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Outbound Notifications
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Send a notification to a specific chat
|
||||
*/
|
||||
async notify(chatId: number, message: string): Promise<boolean> {
|
||||
return this.sendMessage(chatId, message)
|
||||
}
|
||||
|
||||
/**
|
||||
* Broadcast a notification to all active chats
|
||||
*/
|
||||
async broadcast(message: string): Promise<void> {
|
||||
for (const [chatId] of this.chatContexts) {
|
||||
await this.sendMessage(chatId, message)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Singleton instance management
|
||||
let instance: Gateway | null = null
|
||||
|
||||
export function getInstance(): Gateway | null {
|
||||
return instance
|
||||
}
|
||||
|
||||
export async function start(config: GatewayConfig): Promise<Gateway> {
|
||||
if (instance) {
|
||||
await instance.stop()
|
||||
}
|
||||
instance = new Gateway(config)
|
||||
await instance.start()
|
||||
return instance
|
||||
}
|
||||
|
||||
export async function stop(): Promise<void> {
|
||||
if (instance) {
|
||||
await instance.stop()
|
||||
instance = null
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,495 @@
|
||||
/**
|
||||
* Lifecycle Hooks for agent-core daemon
|
||||
*
|
||||
* Provides hook events for daemon, session, and todo lifecycles.
|
||||
* Integrates with tiara's hook system for coordination.
|
||||
*/
|
||||
|
||||
import z from "zod"
|
||||
import { BusEvent } from "../bus/bus-event"
|
||||
import { Bus } from "../bus"
|
||||
import { Log } from "../util/log"
|
||||
import { Todo } from "../session/todo"
|
||||
import { Persistence } from "../session/persistence"
|
||||
|
||||
const log = Log.create({ service: "lifecycle-hooks" })
|
||||
|
||||
export namespace LifecycleHooks {
|
||||
// -------------------------------------------------------------------------
|
||||
// Event Definitions
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
export namespace Daemon {
|
||||
export const Start = BusEvent.define(
|
||||
"daemon.start",
|
||||
z.object({
|
||||
pid: z.number(),
|
||||
port: z.number(),
|
||||
hostname: z.string(),
|
||||
directory: z.string(),
|
||||
startTime: z.number(),
|
||||
})
|
||||
)
|
||||
|
||||
export const Ready = BusEvent.define(
|
||||
"daemon.ready",
|
||||
z.object({
|
||||
pid: z.number(),
|
||||
port: z.number(),
|
||||
services: z.object({
|
||||
persistence: z.boolean(),
|
||||
telegram: z.boolean(),
|
||||
discord: z.boolean(),
|
||||
}),
|
||||
sessionsWithIncompleteTodos: z.number(),
|
||||
})
|
||||
)
|
||||
|
||||
export const Shutdown = BusEvent.define(
|
||||
"daemon.shutdown",
|
||||
z.object({
|
||||
pid: z.number(),
|
||||
reason: z.enum(["signal", "error", "manual"]),
|
||||
signal: z.string().optional(),
|
||||
error: z.string().optional(),
|
||||
uptime: z.number(),
|
||||
})
|
||||
)
|
||||
|
||||
export type StartPayload = z.infer<typeof Start.properties>
|
||||
export type ReadyPayload = z.infer<typeof Ready.properties>
|
||||
export type ShutdownPayload = z.infer<typeof Shutdown.properties>
|
||||
}
|
||||
|
||||
export namespace SessionLifecycle {
|
||||
export const Start = BusEvent.define(
|
||||
"session.lifecycle.start",
|
||||
z.object({
|
||||
sessionId: z.string(),
|
||||
persona: z.enum(["zee", "stanley", "johny"]),
|
||||
source: z.enum(["daemon", "telegram", "tui", "cli"]),
|
||||
chatId: z.number().optional(),
|
||||
directory: z.string(),
|
||||
})
|
||||
)
|
||||
|
||||
export const Restore = BusEvent.define(
|
||||
"session.lifecycle.restore",
|
||||
z.object({
|
||||
sessionId: z.string(),
|
||||
persona: z.enum(["zee", "stanley", "johny"]),
|
||||
source: z.enum(["daemon", "telegram", "tui", "cli"]),
|
||||
chatId: z.number().optional(),
|
||||
hasTodos: z.boolean(),
|
||||
incompleteTodos: z.number(),
|
||||
triggerContinuation: z.boolean(),
|
||||
})
|
||||
)
|
||||
|
||||
export const End = BusEvent.define(
|
||||
"session.lifecycle.end",
|
||||
z.object({
|
||||
sessionId: z.string(),
|
||||
persona: z.enum(["zee", "stanley", "johny"]).optional(),
|
||||
reason: z.enum(["completed", "suspended", "timeout", "error"]),
|
||||
duration: z.number(),
|
||||
todosCompleted: z.number(),
|
||||
todosRemaining: z.number(),
|
||||
})
|
||||
)
|
||||
|
||||
export const Transfer = BusEvent.define(
|
||||
"session.lifecycle.transfer",
|
||||
z.object({
|
||||
sessionId: z.string(),
|
||||
fromContext: z.enum(["daemon", "telegram", "tui", "cli"]),
|
||||
toContext: z.enum(["daemon", "telegram", "tui", "cli"]),
|
||||
fromDevice: z.string().optional(),
|
||||
toDevice: z.string().optional(),
|
||||
})
|
||||
)
|
||||
|
||||
export type StartPayload = z.infer<typeof Start.properties>
|
||||
export type RestorePayload = z.infer<typeof Restore.properties>
|
||||
export type EndPayload = z.infer<typeof End.properties>
|
||||
export type TransferPayload = z.infer<typeof Transfer.properties>
|
||||
}
|
||||
|
||||
export namespace TodoLifecycle {
|
||||
export const Continuation = BusEvent.define(
|
||||
"todo.lifecycle.continuation",
|
||||
z.object({
|
||||
sessionId: z.string(),
|
||||
totalTodos: z.number(),
|
||||
completedTodos: z.number(),
|
||||
remainingTodos: z.number(),
|
||||
percentage: z.number(),
|
||||
proceedWithoutAsking: z.boolean(),
|
||||
reminderMessage: z.string(),
|
||||
})
|
||||
)
|
||||
|
||||
export const Completed = BusEvent.define(
|
||||
"todo.lifecycle.completed",
|
||||
z.object({
|
||||
sessionId: z.string(),
|
||||
totalTodos: z.number(),
|
||||
duration: z.number(),
|
||||
})
|
||||
)
|
||||
|
||||
export const Blocked = BusEvent.define(
|
||||
"todo.lifecycle.blocked",
|
||||
z.object({
|
||||
sessionId: z.string(),
|
||||
todoId: z.string(),
|
||||
todoContent: z.string(),
|
||||
reason: z.string(),
|
||||
needsInput: z.boolean(),
|
||||
})
|
||||
)
|
||||
|
||||
export type ContinuationPayload = z.infer<typeof Continuation.properties>
|
||||
export type CompletedPayload = z.infer<typeof Completed.properties>
|
||||
export type BlockedPayload = z.infer<typeof Blocked.properties>
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Hook Execution
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
interface HookHandler<T> {
|
||||
(payload: T): Promise<void> | void
|
||||
}
|
||||
|
||||
const handlers: Map<string, Array<HookHandler<any>>> = new Map()
|
||||
|
||||
/**
|
||||
* Register a hook handler
|
||||
*/
|
||||
export function on<T>(event: { type: string }, handler: HookHandler<T>): () => void {
|
||||
const eventType = event.type
|
||||
if (!handlers.has(eventType)) {
|
||||
handlers.set(eventType, [])
|
||||
}
|
||||
handlers.get(eventType)!.push(handler)
|
||||
|
||||
// Return unsubscribe function
|
||||
return () => {
|
||||
const list = handlers.get(eventType)
|
||||
if (list) {
|
||||
const index = list.indexOf(handler)
|
||||
if (index !== -1) {
|
||||
list.splice(index, 1)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute registered hook handlers
|
||||
*/
|
||||
async function executeHandlers<T>(eventType: string, payload: T): Promise<void> {
|
||||
const list = handlers.get(eventType) || []
|
||||
for (const handler of list) {
|
||||
try {
|
||||
await handler(payload)
|
||||
} catch (error) {
|
||||
log.error("Hook handler error", {
|
||||
eventType,
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Daemon Lifecycle Functions
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
let daemonStartTime: number | null = null
|
||||
|
||||
export async function emitDaemonStart(payload: Daemon.StartPayload): Promise<void> {
|
||||
daemonStartTime = payload.startTime
|
||||
log.info("Emitting daemon.start hook", { pid: payload.pid, port: payload.port })
|
||||
|
||||
Bus.publish(Daemon.Start, payload)
|
||||
await executeHandlers(Daemon.Start.type, payload)
|
||||
}
|
||||
|
||||
export async function emitDaemonReady(payload: Daemon.ReadyPayload): Promise<void> {
|
||||
log.info("Emitting daemon.ready hook", {
|
||||
pid: payload.pid,
|
||||
services: payload.services,
|
||||
sessionsWithIncompleteTodos: payload.sessionsWithIncompleteTodos,
|
||||
})
|
||||
|
||||
Bus.publish(Daemon.Ready, payload)
|
||||
await executeHandlers(Daemon.Ready.type, payload)
|
||||
}
|
||||
|
||||
export async function emitDaemonShutdown(
|
||||
payload: Omit<Daemon.ShutdownPayload, "uptime">
|
||||
): Promise<void> {
|
||||
const uptime = daemonStartTime ? Date.now() - daemonStartTime : 0
|
||||
const fullPayload: Daemon.ShutdownPayload = { ...payload, uptime }
|
||||
|
||||
log.info("Emitting daemon.shutdown hook", {
|
||||
pid: payload.pid,
|
||||
reason: payload.reason,
|
||||
uptime,
|
||||
})
|
||||
|
||||
Bus.publish(Daemon.Shutdown, fullPayload)
|
||||
await executeHandlers(Daemon.Shutdown.type, fullPayload)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Session Lifecycle Functions
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
const sessionStartTimes: Map<string, number> = new Map()
|
||||
|
||||
export async function emitSessionStart(payload: SessionLifecycle.StartPayload): Promise<void> {
|
||||
sessionStartTimes.set(payload.sessionId, Date.now())
|
||||
log.info("Emitting session.start hook", {
|
||||
sessionId: payload.sessionId,
|
||||
persona: payload.persona,
|
||||
source: payload.source,
|
||||
})
|
||||
|
||||
Bus.publish(SessionLifecycle.Start, payload)
|
||||
await executeHandlers(SessionLifecycle.Start.type, payload)
|
||||
|
||||
// Update last active in persistence
|
||||
if (payload.chatId !== undefined) {
|
||||
try {
|
||||
await Persistence.setLastActive(payload.persona, payload.sessionId, payload.chatId)
|
||||
} catch (e) {
|
||||
log.warn("Failed to set last active", { error: String(e) })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export async function emitSessionRestore(
|
||||
payload: SessionLifecycle.RestorePayload
|
||||
): Promise<void> {
|
||||
sessionStartTimes.set(payload.sessionId, Date.now())
|
||||
log.info("Emitting session.restore hook", {
|
||||
sessionId: payload.sessionId,
|
||||
persona: payload.persona,
|
||||
hasTodos: payload.hasTodos,
|
||||
incompleteTodos: payload.incompleteTodos,
|
||||
})
|
||||
|
||||
Bus.publish(SessionLifecycle.Restore, payload)
|
||||
await executeHandlers(SessionLifecycle.Restore.type, payload)
|
||||
|
||||
// If there are incomplete todos and continuation is triggered, emit continuation hook
|
||||
if (payload.triggerContinuation && payload.incompleteTodos > 0) {
|
||||
await emitTodoContinuation(payload.sessionId, payload.persona)
|
||||
}
|
||||
|
||||
// Update last active in persistence
|
||||
if (payload.chatId !== undefined) {
|
||||
try {
|
||||
await Persistence.setLastActive(payload.persona, payload.sessionId, payload.chatId)
|
||||
} catch (e) {
|
||||
log.warn("Failed to set last active", { error: String(e) })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export async function emitSessionEnd(payload: SessionLifecycle.EndPayload): Promise<void> {
|
||||
const startTime = sessionStartTimes.get(payload.sessionId)
|
||||
const duration = startTime ? Date.now() - startTime : payload.duration
|
||||
const fullPayload = { ...payload, duration }
|
||||
|
||||
log.info("Emitting session.end hook", {
|
||||
sessionId: payload.sessionId,
|
||||
reason: payload.reason,
|
||||
duration,
|
||||
})
|
||||
|
||||
Bus.publish(SessionLifecycle.End, fullPayload)
|
||||
await executeHandlers(SessionLifecycle.End.type, fullPayload)
|
||||
sessionStartTimes.delete(payload.sessionId)
|
||||
}
|
||||
|
||||
export async function emitSessionTransfer(
|
||||
payload: SessionLifecycle.TransferPayload
|
||||
): Promise<void> {
|
||||
log.info("Emitting session.transfer hook", {
|
||||
sessionId: payload.sessionId,
|
||||
from: payload.fromContext,
|
||||
to: payload.toContext,
|
||||
})
|
||||
|
||||
Bus.publish(SessionLifecycle.Transfer, payload)
|
||||
await executeHandlers(SessionLifecycle.Transfer.type, payload)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Todo Lifecycle Functions
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
export async function emitTodoContinuation(
|
||||
sessionId: string,
|
||||
persona?: "zee" | "stanley" | "johny"
|
||||
): Promise<TodoLifecycle.ContinuationPayload | null> {
|
||||
try {
|
||||
const todos = await Todo.get(sessionId)
|
||||
const completedTodos = todos.filter((t) => t.status === "completed").length
|
||||
const remainingTodos = todos.filter(
|
||||
(t) => t.status !== "completed" && t.status !== "cancelled"
|
||||
).length
|
||||
const totalTodos = todos.length
|
||||
const percentage = totalTodos > 0 ? Math.round((completedTodos / totalTodos) * 100) : 100
|
||||
|
||||
if (remainingTodos === 0) {
|
||||
log.debug("No incomplete todos, skipping continuation", { sessionId })
|
||||
return null
|
||||
}
|
||||
|
||||
const reminderMessage = generateReminderMessage(completedTodos, totalTodos, remainingTodos)
|
||||
|
||||
const payload: TodoLifecycle.ContinuationPayload = {
|
||||
sessionId,
|
||||
totalTodos,
|
||||
completedTodos,
|
||||
remainingTodos,
|
||||
percentage,
|
||||
proceedWithoutAsking: true,
|
||||
reminderMessage,
|
||||
}
|
||||
|
||||
log.info("Emitting todo.continuation hook", {
|
||||
sessionId,
|
||||
completedTodos,
|
||||
remainingTodos,
|
||||
percentage,
|
||||
})
|
||||
|
||||
Bus.publish(TodoLifecycle.Continuation, payload)
|
||||
await executeHandlers(TodoLifecycle.Continuation.type, payload)
|
||||
|
||||
return payload
|
||||
} catch (e) {
|
||||
log.error("Failed to emit todo continuation", { sessionId, error: String(e) })
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
export async function emitTodoCompleted(sessionId: string): Promise<void> {
|
||||
const startTime = sessionStartTimes.get(sessionId)
|
||||
const duration = startTime ? Date.now() - startTime : 0
|
||||
|
||||
try {
|
||||
const todos = await Todo.get(sessionId)
|
||||
const totalTodos = todos.length
|
||||
|
||||
const payload: TodoLifecycle.CompletedPayload = {
|
||||
sessionId,
|
||||
totalTodos,
|
||||
duration,
|
||||
}
|
||||
|
||||
log.info("Emitting todo.completed hook", {
|
||||
sessionId,
|
||||
totalTodos,
|
||||
duration,
|
||||
})
|
||||
|
||||
Bus.publish(TodoLifecycle.Completed, payload)
|
||||
await executeHandlers(TodoLifecycle.Completed.type, payload)
|
||||
} catch (e) {
|
||||
log.error("Failed to emit todo completed", { sessionId, error: String(e) })
|
||||
}
|
||||
}
|
||||
|
||||
export async function emitTodoBlocked(
|
||||
sessionId: string,
|
||||
todoId: string,
|
||||
todoContent: string,
|
||||
reason: string,
|
||||
needsInput: boolean = true
|
||||
): Promise<void> {
|
||||
const payload: TodoLifecycle.BlockedPayload = {
|
||||
sessionId,
|
||||
todoId,
|
||||
todoContent,
|
||||
reason,
|
||||
needsInput,
|
||||
}
|
||||
|
||||
log.info("Emitting todo.blocked hook", {
|
||||
sessionId,
|
||||
todoId,
|
||||
reason,
|
||||
})
|
||||
|
||||
Bus.publish(TodoLifecycle.Blocked, payload)
|
||||
await executeHandlers(TodoLifecycle.Blocked.type, payload)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Helper Functions
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
function generateReminderMessage(
|
||||
completed: number,
|
||||
total: number,
|
||||
remaining: number
|
||||
): string {
|
||||
const lines: string[] = [
|
||||
"[SYSTEM REMINDER - TODO CONTINUATION]",
|
||||
"",
|
||||
"Incomplete tasks remain in your todo list. Continue working on the next pending task.",
|
||||
"",
|
||||
"- Proceed without asking for permission",
|
||||
"- Mark each task complete when finished",
|
||||
"- Do not stop until all tasks are done",
|
||||
"",
|
||||
`[Status: ${completed}/${total} completed, ${remaining} remaining]`,
|
||||
]
|
||||
return lines.join("\n")
|
||||
}
|
||||
|
||||
/**
|
||||
* Check all sessions for incomplete todos and trigger continuation hooks
|
||||
* Called on daemon startup
|
||||
*/
|
||||
export async function checkAllSessionsForContinuation(): Promise<number> {
|
||||
let continuationCount = 0
|
||||
|
||||
try {
|
||||
const sessionsWithTodos = await Persistence.getSessionsWithIncompleteTodos()
|
||||
|
||||
for (const { session, incompleteTodos } of sessionsWithTodos) {
|
||||
if (incompleteTodos.length > 0) {
|
||||
log.info("Session has incomplete todos", {
|
||||
sessionId: session.id,
|
||||
title: session.title,
|
||||
incomplete: incompleteTodos.length,
|
||||
})
|
||||
continuationCount++
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
log.error("Failed to check sessions for continuation", { error: String(e) })
|
||||
}
|
||||
|
||||
return continuationCount
|
||||
}
|
||||
|
||||
/**
|
||||
* Format a todo continuation reminder for injection into conversation
|
||||
*/
|
||||
export function formatContinuationReminder(
|
||||
payload: TodoLifecycle.ContinuationPayload
|
||||
): string {
|
||||
return `<system-reminder>
|
||||
${payload.reminderMessage}
|
||||
</system-reminder>`
|
||||
}
|
||||
}
|
||||
@@ -27,6 +27,7 @@ import { EOL } from "os"
|
||||
import { WebCommand } from "./cli/cmd/web"
|
||||
import { PrCommand } from "./cli/cmd/pr"
|
||||
import { SessionCommand } from "./cli/cmd/session"
|
||||
import { DaemonCommand, DaemonStatusCommand, DaemonStopCommand } from "./cli/cmd/daemon"
|
||||
|
||||
process.on("unhandledRejection", (e) => {
|
||||
Log.Default.error("rejection", {
|
||||
@@ -99,6 +100,9 @@ const cli = yargs(hideBin(process.argv))
|
||||
.command(GithubCommand)
|
||||
.command(PrCommand)
|
||||
.command(SessionCommand)
|
||||
.command(DaemonCommand)
|
||||
.command(DaemonStatusCommand)
|
||||
.command(DaemonStopCommand)
|
||||
.fail((msg) => {
|
||||
if (
|
||||
msg?.startsWith("Unknown argument") ||
|
||||
|
||||
@@ -0,0 +1,496 @@
|
||||
/**
|
||||
* WezTerm Orchestration for Daemon
|
||||
*
|
||||
* Provides visual orchestration when a display is available.
|
||||
* Creates status panes showing daemon state, sessions, and tasks.
|
||||
*
|
||||
* Architecture:
|
||||
* - Detects X11/Wayland display availability
|
||||
* - Creates status pane at bottom showing daemon health
|
||||
* - Can spawn panes for active sessions when requested
|
||||
* - Gracefully degrades when no display is available
|
||||
*/
|
||||
|
||||
import { exec } from "node:child_process"
|
||||
import { promisify } from "node:util"
|
||||
import { Log } from "../util/log"
|
||||
import { Bus } from "../bus"
|
||||
import { LifecycleHooks } from "../hooks/lifecycle"
|
||||
import { Session } from "../session"
|
||||
import { Todo } from "../session/todo"
|
||||
|
||||
const execAsync = promisify(exec)
|
||||
const log = Log.create({ service: "wezterm-orchestration" })
|
||||
|
||||
export namespace WeztermOrchestration {
|
||||
// -------------------------------------------------------------------------
|
||||
// Configuration
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
export interface Config {
|
||||
/** Enable WezTerm orchestration (default: true if display available) */
|
||||
enabled: boolean
|
||||
/** Layout for session panes */
|
||||
layout: "horizontal" | "vertical" | "grid"
|
||||
/** Show status pane at bottom */
|
||||
showStatusPane: boolean
|
||||
/** Status pane height as percentage */
|
||||
statusPanePercent: number
|
||||
/** Auto-refresh interval for status (ms) */
|
||||
statusRefreshInterval: number
|
||||
}
|
||||
|
||||
const DEFAULT_CONFIG: Config = {
|
||||
enabled: true,
|
||||
layout: "horizontal",
|
||||
showStatusPane: true,
|
||||
statusPanePercent: 20,
|
||||
statusRefreshInterval: 5000,
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// State
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
interface DaemonStatus {
|
||||
pid: number
|
||||
port: number
|
||||
hostname: string
|
||||
uptime: number
|
||||
services: {
|
||||
persistence: boolean
|
||||
telegram: boolean
|
||||
discord: boolean
|
||||
}
|
||||
sessions: {
|
||||
total: number
|
||||
withIncompleteTodos: number
|
||||
}
|
||||
telegramChats: number
|
||||
}
|
||||
|
||||
let config: Config = DEFAULT_CONFIG
|
||||
let statusPaneId: string | null = null
|
||||
let sessionPanes = new Map<string, string>() // sessionId -> paneId
|
||||
let statusRefreshTimer: NodeJS.Timeout | null = null
|
||||
let isInitialized = false
|
||||
let daemonStartTime = Date.now()
|
||||
|
||||
// Cached daemon status
|
||||
let cachedStatus: Partial<DaemonStatus> = {}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Display Detection
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Check if a graphical display is available
|
||||
*/
|
||||
export async function isDisplayAvailable(): Promise<boolean> {
|
||||
// Check for X11 or Wayland display
|
||||
const display = process.env.DISPLAY
|
||||
const waylandDisplay = process.env.WAYLAND_DISPLAY
|
||||
|
||||
if (!display && !waylandDisplay) {
|
||||
log.debug("No display environment variable set")
|
||||
return false
|
||||
}
|
||||
|
||||
// Try to run a simple X/Wayland command to verify display works
|
||||
try {
|
||||
if (display) {
|
||||
await execAsync("xdpyinfo -display $DISPLAY >/dev/null 2>&1", { timeout: 2000 })
|
||||
return true
|
||||
}
|
||||
if (waylandDisplay) {
|
||||
// For Wayland, check if wezterm can access the display
|
||||
await execAsync("wezterm cli list --format json >/dev/null 2>&1", { timeout: 2000 })
|
||||
return true
|
||||
}
|
||||
} catch {
|
||||
log.debug("Display check failed - display may not be accessible")
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if WezTerm CLI is available
|
||||
*/
|
||||
export async function isWeztermAvailable(): Promise<boolean> {
|
||||
try {
|
||||
await execAsync("wezterm cli list --format json", { timeout: 5000 })
|
||||
return true
|
||||
} catch {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Initialization
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Initialize WezTerm orchestration
|
||||
*/
|
||||
export async function init(userConfig: Partial<Config> = {}): Promise<boolean> {
|
||||
config = { ...DEFAULT_CONFIG, ...userConfig }
|
||||
|
||||
if (!config.enabled) {
|
||||
log.info("WezTerm orchestration disabled by configuration")
|
||||
return false
|
||||
}
|
||||
|
||||
// Check if display is available
|
||||
const displayAvailable = await isDisplayAvailable()
|
||||
if (!displayAvailable) {
|
||||
log.info("No display available, WezTerm orchestration disabled")
|
||||
return false
|
||||
}
|
||||
|
||||
// Check if WezTerm is available
|
||||
const weztermAvailable = await isWeztermAvailable()
|
||||
if (!weztermAvailable) {
|
||||
log.info("WezTerm CLI not available, orchestration disabled")
|
||||
return false
|
||||
}
|
||||
|
||||
log.info("WezTerm orchestration initialized", {
|
||||
layout: config.layout,
|
||||
showStatusPane: config.showStatusPane,
|
||||
})
|
||||
|
||||
// Subscribe to lifecycle hooks
|
||||
setupHookSubscriptions()
|
||||
|
||||
isInitialized = true
|
||||
return true
|
||||
}
|
||||
|
||||
/**
|
||||
* Set up status pane after daemon is ready
|
||||
*/
|
||||
export async function setupStatusPane(status: DaemonStatus): Promise<void> {
|
||||
if (!isInitialized || !config.showStatusPane) return
|
||||
|
||||
cachedStatus = status
|
||||
daemonStartTime = Date.now() - (status.uptime || 0)
|
||||
|
||||
try {
|
||||
// Create status pane at bottom
|
||||
const { stdout } = await execAsync(
|
||||
`wezterm cli split-pane --bottom --percent ${config.statusPanePercent}`
|
||||
)
|
||||
statusPaneId = stdout.trim()
|
||||
|
||||
// Set pane title
|
||||
await setPaneTitle(statusPaneId, "🔺 Agent-Core Daemon Status")
|
||||
|
||||
// Initial status render
|
||||
await updateStatusPane()
|
||||
|
||||
// Start refresh timer
|
||||
if (config.statusRefreshInterval > 0) {
|
||||
statusRefreshTimer = setInterval(() => {
|
||||
updateStatusPane().catch((e) => log.debug("Status refresh failed", { error: String(e) }))
|
||||
}, config.statusRefreshInterval)
|
||||
}
|
||||
|
||||
log.info("Status pane created", { paneId: statusPaneId })
|
||||
} catch (error) {
|
||||
log.warn("Failed to create status pane", {
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Shutdown WezTerm orchestration
|
||||
*/
|
||||
export async function shutdown(): Promise<void> {
|
||||
if (statusRefreshTimer) {
|
||||
clearInterval(statusRefreshTimer)
|
||||
statusRefreshTimer = null
|
||||
}
|
||||
|
||||
// Close all session panes
|
||||
for (const [sessionId, paneId] of sessionPanes) {
|
||||
try {
|
||||
await execAsync(`wezterm cli kill-pane --pane-id ${paneId}`)
|
||||
} catch {
|
||||
// Pane may already be closed
|
||||
}
|
||||
}
|
||||
sessionPanes.clear()
|
||||
|
||||
// Close status pane
|
||||
if (statusPaneId) {
|
||||
try {
|
||||
await execAsync(`wezterm cli kill-pane --pane-id ${statusPaneId}`)
|
||||
} catch {
|
||||
// Pane may already be closed
|
||||
}
|
||||
statusPaneId = null
|
||||
}
|
||||
|
||||
isInitialized = false
|
||||
log.info("WezTerm orchestration shutdown complete")
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Hook Subscriptions
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
function setupHookSubscriptions(): void {
|
||||
// Subscribe to daemon ready
|
||||
Bus.subscribe(LifecycleHooks.Daemon.Ready, async (event) => {
|
||||
const status: DaemonStatus = {
|
||||
pid: event.properties.pid,
|
||||
port: event.properties.port,
|
||||
hostname: "localhost",
|
||||
uptime: 0,
|
||||
services: event.properties.services,
|
||||
sessions: {
|
||||
total: 0,
|
||||
withIncompleteTodos: event.properties.sessionsWithIncompleteTodos,
|
||||
},
|
||||
telegramChats: 0,
|
||||
}
|
||||
await setupStatusPane(status)
|
||||
})
|
||||
|
||||
// Subscribe to session events for updates
|
||||
Bus.subscribe(LifecycleHooks.SessionLifecycle.Start, async () => {
|
||||
await updateStatusPane()
|
||||
})
|
||||
|
||||
Bus.subscribe(LifecycleHooks.SessionLifecycle.Restore, async () => {
|
||||
await updateStatusPane()
|
||||
})
|
||||
|
||||
// Subscribe to todo events
|
||||
Bus.subscribe(LifecycleHooks.TodoLifecycle.Continuation, async () => {
|
||||
await updateStatusPane()
|
||||
})
|
||||
|
||||
Bus.subscribe(LifecycleHooks.TodoLifecycle.Completed, async () => {
|
||||
await updateStatusPane()
|
||||
})
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Status Pane Rendering
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
async function updateStatusPane(): Promise<void> {
|
||||
if (!statusPaneId) return
|
||||
|
||||
try {
|
||||
// Gather current stats
|
||||
let sessionCount = 0
|
||||
let sessionsWithTodos = 0
|
||||
|
||||
try {
|
||||
for await (const session of Session.list()) {
|
||||
sessionCount++
|
||||
const todos = await Todo.get(session.id)
|
||||
const incomplete = todos.filter(
|
||||
(t) => t.status !== "completed" && t.status !== "cancelled"
|
||||
).length
|
||||
if (incomplete > 0) sessionsWithTodos++
|
||||
}
|
||||
} catch {
|
||||
// Session listing may not be available
|
||||
}
|
||||
|
||||
const uptime = Math.floor((Date.now() - daemonStartTime) / 1000)
|
||||
const uptimeStr = formatUptime(uptime)
|
||||
|
||||
const lines: string[] = []
|
||||
lines.push("\\033[2J\\033[H") // Clear screen
|
||||
|
||||
// Header
|
||||
lines.push("╔════════════════════════════════════════════════════════╗")
|
||||
lines.push("║ 🔺 AGENT-CORE DAEMON STATUS 🔺 ║")
|
||||
lines.push("╠════════════════════════════════════════════════════════╣")
|
||||
|
||||
// Daemon info
|
||||
lines.push(`║ PID: ${String(cachedStatus.pid || process.pid).padEnd(10)} Port: ${String(cachedStatus.port || "N/A").padEnd(8)} Uptime: ${uptimeStr.padEnd(12)}║`)
|
||||
|
||||
lines.push("╠════════════════════════════════════════════════════════╣")
|
||||
|
||||
// Services
|
||||
const persistence = cachedStatus.services?.persistence ? "✅" : "❌"
|
||||
const telegram = cachedStatus.services?.telegram ? "✅" : "❌"
|
||||
const discord = cachedStatus.services?.discord ? "✅" : "⚪"
|
||||
const wezterm = isInitialized ? "✅" : "❌"
|
||||
|
||||
lines.push(`║ Services: Persistence ${persistence} Telegram ${telegram} Discord ${discord} WezTerm ${wezterm} ║`)
|
||||
|
||||
lines.push("╠════════════════════════════════════════════════════════╣")
|
||||
|
||||
// Sessions
|
||||
lines.push(`║ Sessions: ${String(sessionCount).padEnd(3)} total ${String(sessionsWithTodos).padEnd(3)} with incomplete todos ║`)
|
||||
|
||||
lines.push("╠════════════════════════════════════════════════════════╣")
|
||||
|
||||
// Time
|
||||
const now = new Date()
|
||||
lines.push(`║ Last Update: ${now.toLocaleTimeString().padEnd(42)}║`)
|
||||
|
||||
lines.push("╚════════════════════════════════════════════════════════╝")
|
||||
|
||||
// Send to pane
|
||||
const output = lines.join("\\n")
|
||||
await execAsync(
|
||||
`wezterm cli send-text --pane-id ${statusPaneId} --no-paste 'echo -e "${output}"'`
|
||||
)
|
||||
await execAsync(`wezterm cli send-text --pane-id ${statusPaneId} --no-paste '\n'`)
|
||||
} catch (error) {
|
||||
log.debug("Failed to update status pane", {
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Session Pane Management
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Create a pane for a session
|
||||
*/
|
||||
export async function createSessionPane(
|
||||
sessionId: string,
|
||||
title: string,
|
||||
persona?: "zee" | "stanley" | "johny"
|
||||
): Promise<string | null> {
|
||||
if (!isInitialized) return null
|
||||
|
||||
try {
|
||||
const direction = config.layout === "vertical" ? "--bottom" : "--right"
|
||||
const percent = config.layout === "grid" ? 50 : 40
|
||||
|
||||
const { stdout } = await execAsync(`wezterm cli split-pane ${direction} --percent ${percent}`)
|
||||
const paneId = stdout.trim()
|
||||
|
||||
// Set title with persona icon
|
||||
const icon = getPersonaIcon(persona)
|
||||
await setPaneTitle(paneId, `${icon} ${title}`)
|
||||
|
||||
sessionPanes.set(sessionId, paneId)
|
||||
|
||||
log.info("Created session pane", { sessionId, paneId, persona })
|
||||
return paneId
|
||||
} catch (error) {
|
||||
log.warn("Failed to create session pane", {
|
||||
sessionId,
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
})
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Close a session pane
|
||||
*/
|
||||
export async function closeSessionPane(sessionId: string): Promise<void> {
|
||||
const paneId = sessionPanes.get(sessionId)
|
||||
if (!paneId) return
|
||||
|
||||
try {
|
||||
await execAsync(`wezterm cli kill-pane --pane-id ${paneId}`)
|
||||
sessionPanes.delete(sessionId)
|
||||
log.info("Closed session pane", { sessionId, paneId })
|
||||
} catch {
|
||||
// Pane may already be closed
|
||||
sessionPanes.delete(sessionId)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Send command to a session pane
|
||||
*/
|
||||
export async function sendToSessionPane(sessionId: string, command: string): Promise<boolean> {
|
||||
const paneId = sessionPanes.get(sessionId)
|
||||
if (!paneId) return false
|
||||
|
||||
try {
|
||||
const escapedCommand = command.replace(/'/g, "'\\''")
|
||||
await execAsync(`wezterm cli send-text --pane-id ${paneId} --no-paste '${escapedCommand}\n'`)
|
||||
return true
|
||||
} catch {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Focus a session pane
|
||||
*/
|
||||
export async function focusSessionPane(sessionId: string): Promise<boolean> {
|
||||
const paneId = sessionPanes.get(sessionId)
|
||||
if (!paneId) return false
|
||||
|
||||
try {
|
||||
await execAsync(`wezterm cli activate-pane --pane-id ${paneId}`)
|
||||
return true
|
||||
} catch {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
async function setPaneTitle(paneId: string, title: string): Promise<void> {
|
||||
const escapeSequence = `\\033]0;${title}\\007`
|
||||
await execAsync(`wezterm cli send-text --pane-id ${paneId} --no-paste $'${escapeSequence}'`)
|
||||
}
|
||||
|
||||
function formatUptime(seconds: number): string {
|
||||
if (seconds < 60) return `${seconds}s`
|
||||
if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`
|
||||
const hours = Math.floor(seconds / 3600)
|
||||
const mins = Math.floor((seconds % 3600) / 60)
|
||||
return `${hours}h ${mins}m`
|
||||
}
|
||||
|
||||
function getPersonaIcon(persona?: "zee" | "stanley" | "johny"): string {
|
||||
switch (persona) {
|
||||
case "zee":
|
||||
return "💜"
|
||||
case "stanley":
|
||||
return "📈"
|
||||
case "johny":
|
||||
return "🧠"
|
||||
default:
|
||||
return "🔹"
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Status Queries
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
export function getStatus(): {
|
||||
initialized: boolean
|
||||
statusPaneId: string | null
|
||||
sessionPaneCount: number
|
||||
displayAvailable: boolean
|
||||
} {
|
||||
return {
|
||||
initialized: isInitialized,
|
||||
statusPaneId,
|
||||
sessionPaneCount: sessionPanes.size,
|
||||
displayAvailable: !!process.env.DISPLAY || !!process.env.WAYLAND_DISPLAY,
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update cached daemon status (called from daemon)
|
||||
*/
|
||||
export function updateDaemonStatus(status: Partial<DaemonStatus>): void {
|
||||
cachedStatus = { ...cachedStatus, ...status }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,532 @@
|
||||
/**
|
||||
* Session Persistence & Recovery
|
||||
*
|
||||
* Provides robust session persistence that survives crashes and restarts:
|
||||
* - Periodic checkpoints of session state
|
||||
* - Write-ahead logging for in-progress operations
|
||||
* - Crash recovery on daemon startup
|
||||
* - Last active session tracking per persona
|
||||
*/
|
||||
|
||||
import { Log } from "../util/log"
|
||||
import { Global } from "../global"
|
||||
import { Storage } from "../storage/storage"
|
||||
import { Bus } from "../bus"
|
||||
import { Session } from "./index"
|
||||
import { Todo } from "./todo"
|
||||
import { MessageV2 } from "./message-v2"
|
||||
import fs from "fs/promises"
|
||||
import path from "path"
|
||||
|
||||
const log = Log.create({ service: "session-persistence" })
|
||||
|
||||
export namespace Persistence {
|
||||
// -------------------------------------------------------------------------
|
||||
// Configuration
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
export interface Config {
|
||||
/** Checkpoint interval in milliseconds (default: 5 minutes) */
|
||||
checkpointInterval: number
|
||||
/** Maximum number of checkpoints to keep (default: 3) */
|
||||
maxCheckpoints: number
|
||||
/** Enable write-ahead logging (default: true) */
|
||||
enableWAL: boolean
|
||||
/** WAL flush interval in milliseconds (default: 1 second) */
|
||||
walFlushInterval: number
|
||||
}
|
||||
|
||||
const DEFAULT_CONFIG: Config = {
|
||||
checkpointInterval: 5 * 60 * 1000, // 5 minutes
|
||||
maxCheckpoints: 3,
|
||||
enableWAL: true,
|
||||
walFlushInterval: 1000,
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// State
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
const PERSISTENCE_DIR = path.join(Global.Path.state, "persistence")
|
||||
const CHECKPOINT_DIR = path.join(PERSISTENCE_DIR, "checkpoints")
|
||||
const WAL_FILE = path.join(PERSISTENCE_DIR, "wal.jsonl")
|
||||
const LAST_ACTIVE_FILE = path.join(PERSISTENCE_DIR, "last-active.json")
|
||||
const RECOVERY_MARKER = path.join(PERSISTENCE_DIR, "recovery-needed")
|
||||
|
||||
interface LastActiveState {
|
||||
zee?: { sessionId: string; chatId?: number; updatedAt: number }
|
||||
stanley?: { sessionId: string; chatId?: number; updatedAt: number }
|
||||
johny?: { sessionId: string; chatId?: number; updatedAt: number }
|
||||
}
|
||||
|
||||
interface WALEntry {
|
||||
timestamp: number
|
||||
operation: "session_create" | "session_update" | "message_create" | "todo_update" | "session_activate"
|
||||
data: Record<string, unknown>
|
||||
}
|
||||
|
||||
interface CheckpointMetadata {
|
||||
id: string
|
||||
timestamp: number
|
||||
sessionCount: number
|
||||
todoCount: number
|
||||
}
|
||||
|
||||
let config: Config = DEFAULT_CONFIG
|
||||
let checkpointInterval: NodeJS.Timeout | null = null
|
||||
let walBuffer: WALEntry[] = []
|
||||
let walFlushInterval: NodeJS.Timeout | null = null
|
||||
let isRunning = false
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Initialization
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
export async function init(userConfig: Partial<Config> = {}): Promise<void> {
|
||||
config = { ...DEFAULT_CONFIG, ...userConfig }
|
||||
|
||||
// Ensure directories exist
|
||||
await fs.mkdir(CHECKPOINT_DIR, { recursive: true })
|
||||
|
||||
// Check if recovery is needed
|
||||
const needsRecovery = await fs
|
||||
.access(RECOVERY_MARKER)
|
||||
.then(() => true)
|
||||
.catch(() => false)
|
||||
|
||||
if (needsRecovery) {
|
||||
log.info("Recovery marker found, running recovery...")
|
||||
await recover()
|
||||
}
|
||||
|
||||
// Create recovery marker (removed on clean shutdown)
|
||||
await fs.writeFile(RECOVERY_MARKER, new Date().toISOString())
|
||||
|
||||
isRunning = true
|
||||
|
||||
// Start checkpoint timer
|
||||
checkpointInterval = setInterval(() => {
|
||||
createCheckpoint().catch((e) => log.error("Checkpoint failed", { error: String(e) }))
|
||||
}, config.checkpointInterval)
|
||||
|
||||
// Start WAL flush timer
|
||||
if (config.enableWAL) {
|
||||
walFlushInterval = setInterval(() => {
|
||||
flushWAL().catch((e) => log.error("WAL flush failed", { error: String(e) }))
|
||||
}, config.walFlushInterval)
|
||||
}
|
||||
|
||||
// Subscribe to events for WAL
|
||||
setupEventListeners()
|
||||
|
||||
log.info("Persistence initialized", {
|
||||
checkpointInterval: config.checkpointInterval,
|
||||
enableWAL: config.enableWAL,
|
||||
})
|
||||
}
|
||||
|
||||
export async function shutdown(): Promise<void> {
|
||||
isRunning = false
|
||||
|
||||
// Stop timers
|
||||
if (checkpointInterval) {
|
||||
clearInterval(checkpointInterval)
|
||||
checkpointInterval = null
|
||||
}
|
||||
if (walFlushInterval) {
|
||||
clearInterval(walFlushInterval)
|
||||
walFlushInterval = null
|
||||
}
|
||||
|
||||
// Flush remaining WAL entries
|
||||
await flushWAL()
|
||||
|
||||
// Create final checkpoint
|
||||
await createCheckpoint()
|
||||
|
||||
// Remove recovery marker (clean shutdown)
|
||||
await fs.unlink(RECOVERY_MARKER).catch(() => {})
|
||||
|
||||
log.info("Persistence shutdown complete")
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Write-Ahead Logging
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
function setupEventListeners(): void {
|
||||
// Listen for session events
|
||||
Bus.subscribe(Session.Event.Created, (event) => {
|
||||
appendToWAL({
|
||||
timestamp: Date.now(),
|
||||
operation: "session_create",
|
||||
data: { session: event.properties.info },
|
||||
})
|
||||
})
|
||||
|
||||
Bus.subscribe(Session.Event.Updated, (event) => {
|
||||
appendToWAL({
|
||||
timestamp: Date.now(),
|
||||
operation: "session_update",
|
||||
data: { session: event.properties.info },
|
||||
})
|
||||
})
|
||||
|
||||
// Listen for message events
|
||||
Bus.subscribe(MessageV2.Event.Updated, (event) => {
|
||||
appendToWAL({
|
||||
timestamp: Date.now(),
|
||||
operation: "message_create",
|
||||
data: { message: event.properties.info },
|
||||
})
|
||||
})
|
||||
|
||||
// Listen for todo events
|
||||
Bus.subscribe(Todo.Event.Updated, (event) => {
|
||||
appendToWAL({
|
||||
timestamp: Date.now(),
|
||||
operation: "todo_update",
|
||||
data: { sessionID: event.properties.sessionID, todos: event.properties.todos },
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
function appendToWAL(entry: WALEntry): void {
|
||||
if (!config.enableWAL || !isRunning) return
|
||||
walBuffer.push(entry)
|
||||
}
|
||||
|
||||
async function flushWAL(): Promise<void> {
|
||||
if (walBuffer.length === 0) return
|
||||
|
||||
const entries = walBuffer
|
||||
walBuffer = []
|
||||
|
||||
const lines = entries.map((e) => JSON.stringify(e)).join("\n") + "\n"
|
||||
|
||||
await fs.appendFile(WAL_FILE, lines).catch((e) => {
|
||||
// Put entries back if write failed
|
||||
walBuffer = [...entries, ...walBuffer]
|
||||
throw e
|
||||
})
|
||||
}
|
||||
|
||||
async function replayWAL(): Promise<number> {
|
||||
let replayed = 0
|
||||
|
||||
try {
|
||||
const content = await fs.readFile(WAL_FILE, "utf-8")
|
||||
const lines = content.split("\n").filter(Boolean)
|
||||
|
||||
for (const line of lines) {
|
||||
try {
|
||||
const entry = JSON.parse(line) as WALEntry
|
||||
await replayWALEntry(entry)
|
||||
replayed++
|
||||
} catch (e) {
|
||||
log.warn("Failed to replay WAL entry", { error: String(e), line: line.substring(0, 100) })
|
||||
}
|
||||
}
|
||||
|
||||
// Clear WAL after successful replay
|
||||
await fs.unlink(WAL_FILE).catch(() => {})
|
||||
} catch (e) {
|
||||
if ((e as NodeJS.ErrnoException).code !== "ENOENT") {
|
||||
log.error("Failed to read WAL", { error: String(e) })
|
||||
}
|
||||
}
|
||||
|
||||
return replayed
|
||||
}
|
||||
|
||||
async function replayWALEntry(entry: WALEntry): Promise<void> {
|
||||
// WAL entries are replayed to ensure state consistency
|
||||
// The actual state should already be in storage, so we mainly
|
||||
// use this to verify and republish events
|
||||
switch (entry.operation) {
|
||||
case "session_create":
|
||||
case "session_update":
|
||||
// Session should already be persisted by Storage
|
||||
log.debug("WAL: session operation", { id: (entry.data.session as Session.Info)?.id })
|
||||
break
|
||||
case "message_create":
|
||||
log.debug("WAL: message operation", { id: (entry.data.message as MessageV2.Info)?.id })
|
||||
break
|
||||
case "todo_update":
|
||||
log.debug("WAL: todo operation", { sessionID: entry.data.sessionID })
|
||||
break
|
||||
case "session_activate":
|
||||
// Re-apply last active session
|
||||
const { persona, sessionId, chatId } = entry.data as {
|
||||
persona: keyof LastActiveState
|
||||
sessionId: string
|
||||
chatId?: number
|
||||
}
|
||||
await setLastActive(persona, sessionId, chatId)
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Checkpoints
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
export async function createCheckpoint(): Promise<string> {
|
||||
const checkpointId = `checkpoint-${Date.now()}`
|
||||
const checkpointPath = path.join(CHECKPOINT_DIR, checkpointId)
|
||||
|
||||
log.info("Creating checkpoint", { id: checkpointId })
|
||||
|
||||
await fs.mkdir(checkpointPath, { recursive: true })
|
||||
|
||||
// Get all sessions
|
||||
const sessions: Session.Info[] = []
|
||||
for await (const session of Session.list()) {
|
||||
sessions.push(session)
|
||||
}
|
||||
|
||||
// Collect all session data with todos
|
||||
let todoCount = 0
|
||||
const sessionData: Array<{
|
||||
session: Session.Info
|
||||
todos: Todo.Info[]
|
||||
}> = []
|
||||
|
||||
for (const session of sessions) {
|
||||
const todos = await Todo.get(session.id)
|
||||
todoCount += todos.length
|
||||
sessionData.push({ session, todos })
|
||||
}
|
||||
|
||||
// Write checkpoint data
|
||||
await fs.writeFile(path.join(checkpointPath, "sessions.json"), JSON.stringify(sessionData, null, 2))
|
||||
|
||||
// Write last active state
|
||||
const lastActive = await getLastActiveState()
|
||||
await fs.writeFile(path.join(checkpointPath, "last-active.json"), JSON.stringify(lastActive, null, 2))
|
||||
|
||||
// Write metadata
|
||||
const metadata: CheckpointMetadata = {
|
||||
id: checkpointId,
|
||||
timestamp: Date.now(),
|
||||
sessionCount: sessions.length,
|
||||
todoCount,
|
||||
}
|
||||
await fs.writeFile(path.join(checkpointPath, "metadata.json"), JSON.stringify(metadata, null, 2))
|
||||
|
||||
log.info("Checkpoint created", {
|
||||
id: checkpointId,
|
||||
sessions: sessions.length,
|
||||
todos: todoCount,
|
||||
})
|
||||
|
||||
// Cleanup old checkpoints
|
||||
await cleanupOldCheckpoints()
|
||||
|
||||
return checkpointId
|
||||
}
|
||||
|
||||
async function cleanupOldCheckpoints(): Promise<void> {
|
||||
try {
|
||||
const entries = await fs.readdir(CHECKPOINT_DIR)
|
||||
const checkpoints = entries
|
||||
.filter((e) => e.startsWith("checkpoint-"))
|
||||
.map((e) => ({
|
||||
name: e,
|
||||
timestamp: parseInt(e.replace("checkpoint-", "")),
|
||||
}))
|
||||
.sort((a, b) => b.timestamp - a.timestamp) // newest first
|
||||
|
||||
// Keep only the newest N checkpoints
|
||||
const toDelete = checkpoints.slice(config.maxCheckpoints)
|
||||
for (const checkpoint of toDelete) {
|
||||
const checkpointPath = path.join(CHECKPOINT_DIR, checkpoint.name)
|
||||
await fs.rm(checkpointPath, { recursive: true }).catch(() => {})
|
||||
log.debug("Deleted old checkpoint", { id: checkpoint.name })
|
||||
}
|
||||
} catch (e) {
|
||||
log.warn("Failed to cleanup checkpoints", { error: String(e) })
|
||||
}
|
||||
}
|
||||
|
||||
async function getLatestCheckpoint(): Promise<string | null> {
|
||||
try {
|
||||
const entries = await fs.readdir(CHECKPOINT_DIR)
|
||||
const checkpoints = entries
|
||||
.filter((e) => e.startsWith("checkpoint-"))
|
||||
.map((e) => ({
|
||||
name: e,
|
||||
timestamp: parseInt(e.replace("checkpoint-", "")),
|
||||
}))
|
||||
.sort((a, b) => b.timestamp - a.timestamp) // newest first
|
||||
|
||||
return checkpoints[0]?.name || null
|
||||
} catch {
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Recovery
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
export async function recover(): Promise<{ checkpointRestored: boolean; walEntriesReplayed: number }> {
|
||||
log.info("Starting recovery...")
|
||||
|
||||
let checkpointRestored = false
|
||||
let walEntriesReplayed = 0
|
||||
|
||||
// Try to restore from latest checkpoint
|
||||
const latestCheckpoint = await getLatestCheckpoint()
|
||||
if (latestCheckpoint) {
|
||||
try {
|
||||
await restoreFromCheckpoint(latestCheckpoint)
|
||||
checkpointRestored = true
|
||||
log.info("Restored from checkpoint", { id: latestCheckpoint })
|
||||
} catch (e) {
|
||||
log.error("Failed to restore from checkpoint", { error: String(e) })
|
||||
}
|
||||
}
|
||||
|
||||
// Replay WAL for any operations after the checkpoint
|
||||
walEntriesReplayed = await replayWAL()
|
||||
|
||||
log.info("Recovery complete", {
|
||||
checkpointRestored,
|
||||
walEntriesReplayed,
|
||||
})
|
||||
|
||||
return { checkpointRestored, walEntriesReplayed }
|
||||
}
|
||||
|
||||
async function restoreFromCheckpoint(checkpointId: string): Promise<void> {
|
||||
const checkpointPath = path.join(CHECKPOINT_DIR, checkpointId)
|
||||
|
||||
// Read metadata
|
||||
const metadataPath = path.join(checkpointPath, "metadata.json")
|
||||
const metadata = JSON.parse(await fs.readFile(metadataPath, "utf-8")) as CheckpointMetadata
|
||||
|
||||
log.info("Restoring checkpoint", {
|
||||
id: checkpointId,
|
||||
timestamp: new Date(metadata.timestamp).toISOString(),
|
||||
sessions: metadata.sessionCount,
|
||||
})
|
||||
|
||||
// Restore last active state
|
||||
const lastActivePath = path.join(checkpointPath, "last-active.json")
|
||||
try {
|
||||
const lastActive = JSON.parse(await fs.readFile(lastActivePath, "utf-8")) as LastActiveState
|
||||
await fs.writeFile(LAST_ACTIVE_FILE, JSON.stringify(lastActive, null, 2))
|
||||
} catch {
|
||||
// Last active state is optional
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Last Active Session Tracking
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
export async function setLastActive(
|
||||
persona: "zee" | "stanley" | "johny",
|
||||
sessionId: string,
|
||||
chatId?: number
|
||||
): Promise<void> {
|
||||
const state = await getLastActiveState()
|
||||
|
||||
state[persona] = {
|
||||
sessionId,
|
||||
chatId,
|
||||
updatedAt: Date.now(),
|
||||
}
|
||||
|
||||
await fs.writeFile(LAST_ACTIVE_FILE, JSON.stringify(state, null, 2))
|
||||
|
||||
// Also log to WAL
|
||||
appendToWAL({
|
||||
timestamp: Date.now(),
|
||||
operation: "session_activate",
|
||||
data: { persona, sessionId, chatId },
|
||||
})
|
||||
|
||||
log.debug("Set last active session", { persona, sessionId, chatId })
|
||||
}
|
||||
|
||||
export async function getLastActive(persona: "zee" | "stanley" | "johny"): Promise<{
|
||||
sessionId: string
|
||||
chatId?: number
|
||||
updatedAt: number
|
||||
} | null> {
|
||||
const state = await getLastActiveState()
|
||||
return state[persona] || null
|
||||
}
|
||||
|
||||
async function getLastActiveState(): Promise<LastActiveState> {
|
||||
try {
|
||||
const content = await fs.readFile(LAST_ACTIVE_FILE, "utf-8")
|
||||
return JSON.parse(content) as LastActiveState
|
||||
} catch {
|
||||
return {}
|
||||
}
|
||||
}
|
||||
|
||||
export async function getAllLastActive(): Promise<LastActiveState> {
|
||||
return getLastActiveState()
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Session Recovery Helpers
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
export interface SessionWithTodos {
|
||||
session: Session.Info
|
||||
todos: Todo.Info[]
|
||||
incompleteTodos: Todo.Info[]
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all sessions that have incomplete todos
|
||||
*/
|
||||
export async function getSessionsWithIncompleteTodos(): Promise<SessionWithTodos[]> {
|
||||
const result: SessionWithTodos[] = []
|
||||
|
||||
for await (const session of Session.list()) {
|
||||
const todos = await Todo.get(session.id)
|
||||
const incompleteTodos = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled")
|
||||
|
||||
if (incompleteTodos.length > 0) {
|
||||
result.push({
|
||||
session,
|
||||
todos,
|
||||
incompleteTodos,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by most recently updated
|
||||
result.sort((a, b) => (b.session.time.updated || 0) - (a.session.time.updated || 0))
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the last active session for a persona with its todos
|
||||
*/
|
||||
export async function getLastActiveSessionWithTodos(
|
||||
persona: "zee" | "stanley" | "johny"
|
||||
): Promise<SessionWithTodos | null> {
|
||||
const lastActive = await getLastActive(persona)
|
||||
if (!lastActive) return null
|
||||
|
||||
try {
|
||||
const session = await Session.get(lastActive.sessionId)
|
||||
if (!session) return null
|
||||
|
||||
const todos = await Todo.get(session.id)
|
||||
const incompleteTodos = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled")
|
||||
|
||||
return { session, todos, incompleteTodos }
|
||||
} catch {
|
||||
return null
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
[Unit]
|
||||
Description=Agent Core - Always-On Personas Daemon
|
||||
Documentation=https://github.com/your-org/agent-core
|
||||
After=network.target
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=artur
|
||||
Group=artur
|
||||
|
||||
# Environment setup
|
||||
Environment=HOME=/home/artur
|
||||
Environment=AGENT_CORE_HEADLESS=1
|
||||
Environment=NODE_ENV=production
|
||||
|
||||
# API keys can be loaded from environment file (create ~/.config/agent-core/daemon.env)
|
||||
EnvironmentFile=-/home/artur/.config/agent-core/daemon.env
|
||||
|
||||
# Working directory and command
|
||||
WorkingDirectory=/home/artur/Repositories/agent-core
|
||||
ExecStart=/home/artur/.bun/bin/bun run packages/opencode/src/cli/index.ts daemon --hostname 127.0.0.1 --port 3456
|
||||
|
||||
# Restart policy
|
||||
Restart=always
|
||||
RestartSec=10
|
||||
TimeoutStopSec=30
|
||||
|
||||
# Security hardening (optional, comment out if issues)
|
||||
NoNewPrivileges=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=read-only
|
||||
ReadWritePaths=/home/artur/.config/agent-core /home/artur/.local/share/agent-core /home/artur/.zee
|
||||
|
||||
# Logging
|
||||
StandardOutput=journal
|
||||
StandardError=journal
|
||||
SyslogIdentifier=agent-core
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
Executable
+93
@@ -0,0 +1,93 @@
|
||||
#!/bin/bash
|
||||
# Install agent-core as a systemd service
|
||||
|
||||
set -e
|
||||
|
||||
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
||||
SERVICE_FILE="$SCRIPT_DIR/agent-core.service"
|
||||
TARGET="/etc/systemd/system/agent-core.service"
|
||||
|
||||
# Check if running as root
|
||||
if [[ $EUID -ne 0 ]]; then
|
||||
echo "This script must be run as root (use sudo)"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Check if service file exists
|
||||
if [[ ! -f "$SERVICE_FILE" ]]; then
|
||||
echo "Error: Service file not found at $SERVICE_FILE"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Copy service file
|
||||
echo "Installing service file to $TARGET..."
|
||||
cp "$SERVICE_FILE" "$TARGET"
|
||||
|
||||
# Create environment file directory if needed
|
||||
mkdir -p /home/artur/.config/agent-core
|
||||
|
||||
# Create environment file template if it doesn't exist
|
||||
ENV_FILE="/home/artur/.config/agent-core/daemon.env"
|
||||
if [[ ! -f "$ENV_FILE" ]]; then
|
||||
echo "Creating environment file template at $ENV_FILE..."
|
||||
cat > "$ENV_FILE" << 'EOF'
|
||||
# Agent Core Daemon Environment Configuration
|
||||
# Add your API keys here (uncomment and fill in)
|
||||
|
||||
# =============================================================================
|
||||
# LLM Provider Keys (at least one required)
|
||||
# =============================================================================
|
||||
|
||||
# Anthropic API key (recommended)
|
||||
# ANTHROPIC_API_KEY=your-key-here
|
||||
|
||||
# OpenAI API key (optional)
|
||||
# OPENAI_API_KEY=your-key-here
|
||||
|
||||
# =============================================================================
|
||||
# Tool API Keys
|
||||
# =============================================================================
|
||||
|
||||
# EXA API key (for web search)
|
||||
# EXA_API_KEY=your-key-here
|
||||
|
||||
# =============================================================================
|
||||
# Telegram Gateway (Phase 2: Remote Access)
|
||||
# =============================================================================
|
||||
|
||||
# Get your bot token from @BotFather on Telegram
|
||||
# TELEGRAM_BOT_TOKEN=123456789:ABCdefGHIjklMNOpqrsTUVwxyz
|
||||
|
||||
# Restrict access to specific Telegram user IDs (comma-separated)
|
||||
# Find your ID by messaging @userinfobot on Telegram
|
||||
# Leave empty to allow all users (not recommended for public bots)
|
||||
# TELEGRAM_ALLOWED_USERS=123456789,987654321
|
||||
|
||||
# =============================================================================
|
||||
# Discord Gateway (Future - Phase 2)
|
||||
# =============================================================================
|
||||
|
||||
# DISCORD_BOT_TOKEN=your-discord-token-here
|
||||
EOF
|
||||
chown artur:artur "$ENV_FILE"
|
||||
chmod 600 "$ENV_FILE"
|
||||
fi
|
||||
|
||||
# Reload systemd
|
||||
echo "Reloading systemd..."
|
||||
systemctl daemon-reload
|
||||
|
||||
echo ""
|
||||
echo "Installation complete!"
|
||||
echo ""
|
||||
echo "Next steps:"
|
||||
echo " 1. Edit your API keys in: $ENV_FILE"
|
||||
echo " 2. Enable the service: sudo systemctl enable agent-core"
|
||||
echo " 3. Start the service: sudo systemctl start agent-core"
|
||||
echo " 4. Check status: sudo systemctl status agent-core"
|
||||
echo " 5. View logs: journalctl -u agent-core -f"
|
||||
echo ""
|
||||
echo "Or use the CLI commands:"
|
||||
echo " opencode daemon # Start in foreground"
|
||||
echo " opencode daemon-status # Check if running"
|
||||
echo " opencode daemon-stop # Stop the daemon"
|
||||
Reference in New Issue
Block a user