Compare commits
3 Commits
fix/drop-w
...
be30b4b3f4
| Author | SHA1 | Date | |
|---|---|---|---|
|
be30b4b3f4 | ||
|
|
7e4750fcc4 | ||
|
|
6d59741086 |
2
.gitignore
vendored
2
.gitignore
vendored
@@ -4,5 +4,3 @@ plugin/**/*.js
|
||||
plugin/**/*.js.map
|
||||
plugin/**/*.d.ts
|
||||
plugin/**/*.d.ts.map
|
||||
# Hand-written ambient declarations are tracked; only compiled .d.ts above is ignored.
|
||||
!plugin/openclaw-sdk.d.ts
|
||||
|
||||
192
README.md
192
README.md
@@ -1,107 +1,84 @@
|
||||
# HarborForge OpenClaw Plugin
|
||||
|
||||
OpenClaw plugin that exposes OpenClaw-side metadata to the HarborForge Monitor, provides an optional local Monitor bridge, drives the HarborForge Calendar scheduler, and can optionally install the `hf` CLI.
|
||||
OpenClaw 插件：向 HarborForge Monitor 暴露 OpenClaw 侧元数据，并提供可选的本地桥接能力；安装时也可顺带安装 `hf` CLI。
|
||||
|
||||
Part of the [HarborForge](../README.md) platform.
|
||||
## 当前状态
|
||||
|
||||
- Role: OpenClaw integration layer for HarborForge (registered plugin id: `harbor-forge`).
|
||||
- Talks to the HarborForge backend (`backendUrl`, default `https://monitor.hangman-lab.top`) for Calendar APIs.
|
||||
- Talks to a local HarborForge.Monitor bridge over `127.0.0.1:<monitor_port>` (no fixed default; commonly `9100`).
|
||||
- 插件注册名：`harbor-forge`
|
||||
- 旧 sidecar `server/` 架构已移除
|
||||
- 监控桥接走本地 `monitor_port`
|
||||
- 安装脚本支持 `--install-cli`
|
||||
- `skills/hf/` 仅在 `--install-cli` 时一并安装
|
||||
|
||||
## Current State
|
||||
|
||||
- Plugin registration id: `harbor-forge` (was `harborforge-monitor`)
|
||||
- Plugin version: `0.2.0` (package manifests); telemetry reports `pluginVersion` `0.3.1`
|
||||
- Legacy sidecar `server/` architecture removed — telemetry is served directly by the plugin
|
||||
- Monitor bridge runs over the local `monitor_port`
|
||||
- Calendar scheduler integration (PLG-CAL-001 / 002 / 004)
|
||||
- Installer supports `--install-cli` and an optional managed Monitor (`--install-monitor`)
|
||||
- `skills/hf/` is installed only with `--install-cli`
|
||||
|
||||
## Project Structure
|
||||
## 项目结构
|
||||
|
||||
```text
|
||||
HarborForge.OpenclawPlugin/
|
||||
├── package.json
|
||||
├── README.md
|
||||
├── docs/ # design notes (calendar, monitor connector)
|
||||
├── plugin/
|
||||
│ ├── openclaw.plugin.json # plugin manifest + config schema
|
||||
│ ├── index.ts # plugin entry, tool registration
|
||||
│ ├── tsconfig.json
|
||||
│ ├── openclaw.plugin.json
|
||||
│ ├── index.ts
|
||||
│ ├── core/
|
||||
│ │ ├── config.ts # config defaults / resolution
|
||||
│ │ ├── managed-monitor.ts # optionally spawn HarborForge.Monitor
|
||||
│ │ ├── monitor-bridge.ts # client for the Monitor bridge
|
||||
│ │ └── openclaw-agents.ts # enumerate OpenClaw agents
|
||||
│ ├── calendar/ # Calendar scheduler + bridge
|
||||
│ │ ├── index.ts
|
||||
│ │ ├── scheduler.ts
|
||||
│ │ ├── calendar-bridge.ts
|
||||
│ │ └── types.ts
|
||||
│ │ ├── config.ts
|
||||
│ │ ├── managed-monitor.ts
|
||||
│ │ └── monitor-bridge.ts
|
||||
│ ├── hooks/
|
||||
│ │ ├── gateway-start.ts
|
||||
│ │ └── gateway-stop.ts
|
||||
│ └── package.json
|
||||
├── skills/
|
||||
│ └── hf/
|
||||
│ └── SKILL.md # installed only with --install-cli
|
||||
│ └── SKILL.md
|
||||
└── scripts/
|
||||
└── install.mjs
|
||||
```
|
||||
|
||||
## Installation
|
||||
## 安装
|
||||
|
||||
### Standard Install
|
||||
### 普通安装
|
||||
|
||||
```bash
|
||||
node scripts/install.mjs
|
||||
```
|
||||
|
||||
This will:
|
||||
- Build and install the OpenClaw plugin
|
||||
- Copy regular skills
|
||||
- **Not** install the `hf` binary
|
||||
- **Not** copy `skills/hf/`
|
||||
这会：
|
||||
- 构建并安装 OpenClaw 插件
|
||||
- 复制常规 skills
|
||||
- **不会**安装 `hf` 二进制
|
||||
- **不会**复制 `skills/hf/`
|
||||
|
||||
### Plugin + `hf` CLI
|
||||
### 安装插件 + `hf` CLI
|
||||
|
||||
```bash
|
||||
node scripts/install.mjs --install-cli
|
||||
```
|
||||
|
||||
This additionally:
|
||||
- Builds `HarborForge.Cli` (`go build ./cmd/hf`)
|
||||
- Installs `hf` to `<openclaw>/bin/hf` (default `~/.openclaw/bin/hf`) and `chmod +x`
|
||||
- Copies `skills/hf/` into the OpenClaw skills directory
|
||||
这会额外：
|
||||
- 构建 `HarborForge.Cli`
|
||||
- 安装 `hf` 到 `~/.openclaw/bin/hf`
|
||||
- `chmod +x ~/.openclaw/bin/hf`
|
||||
- 复制 `skills/hf/` 到 OpenClaw profile skills 目录
|
||||
|
||||
### Common Options
|
||||
### 常用选项
|
||||
|
||||
```bash
|
||||
# Build only (no install / config)
|
||||
# 仅构建
|
||||
node scripts/install.mjs --build-only
|
||||
|
||||
# Install only, skip dependency checks
|
||||
node scripts/install.mjs --skip-check
|
||||
|
||||
# Specify OpenClaw profile path (also honors OPENCLAW_PATH env)
|
||||
# 指定 OpenClaw profile
|
||||
node scripts/install.mjs --openclaw-profile-path /custom/path/.openclaw
|
||||
|
||||
# Build and install a managed HarborForge.Monitor binary alongside the plugin
|
||||
node scripts/install.mjs --install-monitor yes --monitor-branch main
|
||||
|
||||
# Verbose logs
|
||||
# 详细日志
|
||||
node scripts/install.mjs --verbose
|
||||
|
||||
# Uninstall (plugin, config entries, hf binary, managed monitor)
|
||||
# 卸载
|
||||
node scripts/install.mjs --uninstall
|
||||
```
|
||||
|
||||
The installer also updates OpenClaw config (`plugins.load.paths`, `plugins.allow`, `plugins.entries.harbor-forge.enabled`) via `openclaw config`.
|
||||
## 配置
|
||||
|
||||
## Configuration
|
||||
|
||||
Edit `~/.openclaw/openclaw.json`:
|
||||
编辑 `~/.openclaw/openclaw.json`：
|
||||
|
||||
```json
|
||||
{
|
||||
@@ -117,9 +94,7 @@ Edit `~/.openclaw/openclaw.json`:
|
||||
"monitor_port": 9100,
|
||||
"reportIntervalSec": 30,
|
||||
"httpFallbackIntervalSec": 60,
|
||||
"logLevel": "info",
|
||||
"calendarEnabled": true,
|
||||
"calendarHeartbeatIntervalSec": 60
|
||||
"logLevel": "info"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -127,72 +102,51 @@ Edit `~/.openclaw/openclaw.json`:
|
||||
}
|
||||
```
|
||||
|
||||
Then restart:
|
||||
然后重启：
|
||||
|
||||
```bash
|
||||
openclaw gateway restart
|
||||
```
|
||||
|
||||
## Config Options
|
||||
## 配置项
|
||||
|
||||
| Option | Type | Default | Description |
|
||||
|--------|------|---------|-------------|
|
||||
| `enabled` | boolean | `true` | Enable the plugin |
|
||||
| `backendUrl` | string | `https://monitor.hangman-lab.top` | HarborForge backend base URL (Monitor + Calendar APIs) |
|
||||
| `identifier` | string | hostname | Server / claw identifier |
|
||||
| `apiKey` | string | (none) | Server API key from the HarborForge Monitor admin panel |
|
||||
| `monitor_port` | number | (none) | Local bridge port; plugin talks to HarborForge.Monitor via `127.0.0.1:<monitor_port>` |
|
||||
| `reportIntervalSec` | number | `30` | Metadata push interval (seconds) |
|
||||
| `httpFallbackIntervalSec` | number | `60` | HTTP heartbeat interval when WS unavailable |
|
||||
| `logLevel` | string | `info` | Log level: `debug` / `info` / `warn` / `error` |
|
||||
| `calendarEnabled` | boolean | `true` | Enable Calendar scheduler integration (PLG-CAL-001) |
|
||||
| `calendarHeartbeatIntervalSec` | number | `60` | Calendar heartbeat interval (seconds) |
|
||||
| `calendarApiKey` | string | (none) | API key for Calendar API auth; falls back to `apiKey` / `X-Agent-ID` |
|
||||
| `managedMonitor` | string | (none) | Absolute path to a HarborForge.Monitor binary; if set, gateway start/stop hooks spawn/stop it |
|
||||
| 选项 | 类型 | 默认值 | 说明 |
|
||||
|------|------|--------|------|
|
||||
| `enabled` | boolean | `true` | 是否启用插件 |
|
||||
| `backendUrl` | string | `https://monitor.hangman-lab.top` | HarborForge Monitor 后端地址 |
|
||||
| `identifier` | string | 主机名 | 服务器标识符 |
|
||||
| `apiKey` | string | 无 | HarborForge Monitor 生成的服务器 API Key |
|
||||
| `monitor_port` | number | 无 | 本地桥接端口；插件通过 `127.0.0.1:<monitor_port>` 与 HarborForge.Monitor 通信 |
|
||||
| `reportIntervalSec` | number | `30` | 报告间隔（秒） |
|
||||
| `httpFallbackIntervalSec` | number | `60` | HTTP 回退间隔（秒） |
|
||||
| `logLevel` | string | `info` | 日志级别：`debug` / `info` / `warn` / `error` |
|
||||
|
||||
## Local Monitor Bridge
|
||||
## 本地桥接说明
|
||||
|
||||
When the plugin has `monitor_port` configured and HarborForge.Monitor uses the same `MONITOR_PORT`:
|
||||
当插件配置了 `monitor_port`，并且 HarborForge.Monitor 也使用相同的 `MONITOR_PORT` 时：
|
||||
|
||||
- Monitor serves a local bridge on `127.0.0.1:<MONITOR_PORT>`
|
||||
- The plugin probes `GET /health`
|
||||
- The plugin tool `harborforge_monitor_telemetry` reads `GET /telemetry`
|
||||
- The plugin pushes OpenClaw metadata (version, plugin version, agents) via `POST /openclaw` on the `reportIntervalSec` cadence, enriching Monitor heartbeats
|
||||
- If the bridge port is unconfigured or unreachable, the plugin still works normally
|
||||
- Monitor 在 `127.0.0.1:<MONITOR_PORT>` 提供本地桥接服务
|
||||
- 插件可探测 `GET /health`
|
||||
- 插件工具 `harborforge_monitor_telemetry` 可读取 `GET /telemetry`
|
||||
- 如果桥接端口未配置或不可达，插件仍可正常运行
|
||||
|
||||
This link is an **optional enhancement**, not a precondition for the plugin to start or for Monitor heartbeats.
|
||||
也就是说，这条链路是**可选增强**，不是插件启动或 Monitor 心跳的前置条件。
|
||||
|
||||
## Managed Monitor
|
||||
## 插件提供的信息
|
||||
|
||||
If `managedMonitor` points to an installed HarborForge.Monitor binary, the `gateway_start` hook spawns it (passing `--backend-url`, `--identifier`, `--api-key`, `--monitor-port`, `--report-interval`, `--log-level` from the plugin config) and `gateway_stop` terminates it. Use `install.mjs --install-monitor yes` to build and wire this automatically.
|
||||
### OpenClaw 元数据
|
||||
- OpenClaw version
|
||||
- plugin version
|
||||
- 标识符 / 主机名
|
||||
- 时间戳
|
||||
|
||||
## Calendar Scheduler
|
||||
### 系统快照
|
||||
- uptime
|
||||
- memory total/free/used/usagePercent
|
||||
- load avg1/avg5/avg15
|
||||
- platform
|
||||
|
||||
When `calendarEnabled` is true, on gateway start the plugin starts a Calendar scheduler that heartbeats the backend (`/calendar/agent/heartbeat`, `/calendar/agent/status`, `/calendar/agent/notify`) to receive and run scheduled TimeSlots, waking/spawning agents via the OpenClaw `spawn` API (with a notification fallback). Scheduler state is persisted to a state file; gateway restarts can be requested by the backend (PLG-CAL-004).
|
||||
|
||||
## Tools Provided
|
||||
|
||||
| Tool | Description |
|
||||
|------|-------------|
|
||||
| `harborforge_status` | Plugin status, resolved config, Monitor bridge health, calendar status, telemetry snapshot |
|
||||
| `harborforge_telemetry` | Current system telemetry snapshot from this host |
|
||||
| `harborforge_monitor_telemetry` | Query the Monitor bridge for host hardware telemetry |
|
||||
| `harborforge_calendar_status` | Calendar scheduler status and current slot |
|
||||
| `harborforge_calendar_complete` | Complete the current calendar slot with actual duration |
|
||||
| `harborforge_calendar_abort` | Abort the current calendar slot |
|
||||
| `harborforge_calendar_pause` | Pause the current calendar slot |
|
||||
| `harborforge_calendar_resume` | Resume the paused calendar slot |
|
||||
| `harborforge_restart_status` | Check whether a gateway restart is pending |
|
||||
|
||||
### Telemetry Snapshot Fields
|
||||
|
||||
- `identifier`, `hostname`, `platform`, `timestamp`
|
||||
- `uptime`
|
||||
- `memory`: `total` / `free` / `used` / `usagePercent`
|
||||
- `load`: `avg1` / `avg5` / `avg15`
|
||||
- `openclaw`: `version` / `pluginVersion`
|
||||
|
||||
## Development
|
||||
## 开发
|
||||
|
||||
```bash
|
||||
cd plugin
|
||||
@@ -200,16 +154,14 @@ npm install
|
||||
npm run build
|
||||
```
|
||||
|
||||
The build runs `tsc` and emits `dist/` (`dist/index.js` is the plugin entry).
|
||||
|
||||
## Dependencies
|
||||
## 依赖
|
||||
|
||||
- Node.js 18+
|
||||
- OpenClaw Gateway
|
||||
- Go 1.20+ (only for `--install-cli` / `--install-monitor`)
|
||||
- Go 1.20+（仅 `--install-cli` 需要）
|
||||
|
||||
## Tips
|
||||
## 相关提示
|
||||
|
||||
- After installing `hf`, add `~/.openclaw/bin` to your `PATH`
|
||||
- When an agent uses `hf`, try `hf --help-brief` first
|
||||
- For the full command tree, see `hf --help`
|
||||
- 安装 `hf` 后，建议把 `~/.openclaw/bin` 加到 `PATH`
|
||||
- Agent 使用 `hf` 时，优先试 `hf --help-brief`
|
||||
- 完整命令树看 `hf --help`
|
||||
|
||||
190
REFACTOR_PLAN.md
190
REFACTOR_PLAN.md
@@ -1,118 +1,112 @@
|
||||
# CalendarScheduler Refactor Plan (v2)
|
||||
# CalendarScheduler Refactor Plan
|
||||
|
||||
> Updated 2026-04-19 based on architecture discussion with hang
|
||||
## Current Design
|
||||
|
||||
## Current Issues
|
||||
```
|
||||
Every 60s:
|
||||
heartbeat() → POST /calendar/agent/heartbeat → returns pending slots
|
||||
if idle → select highest priority → executeSlot → wakeAgent(spawn)
|
||||
if busy → defer all pending slots
|
||||
```
|
||||
|
||||
1. `process.env.AGENT_ID` doesn't exist in plugins subprocess — always 'unknown'
|
||||
2. Heartbeat is per-agent but should be per-claw-instance (global)
|
||||
3. Scheduler only handles one agent — should manage all agents on this instance
|
||||
4. wakeAgent used api.spawn (non-existent) → now uses dispatchInboundMessage (verified)
|
||||
**Problems:**
|
||||
1. Every heartbeat queries backend for pending slots — no local awareness of full schedule
|
||||
2. Cannot detect slots assigned by other agents between heartbeats
|
||||
3. 60s interval is too frequent for sync but too infrequent for precise wakeup
|
||||
4. Wakeup via `api.spawn()` creates a plain session, not a Discord private channel
|
||||
|
||||
## Target Design
|
||||
|
||||
### Plugin State
|
||||
```
|
||||
Every 5-10 min (sync interval):
|
||||
syncSchedule() → GET /calendar/day → update local today cache
|
||||
|
||||
Every 30s (check interval):
|
||||
checkDueSlots() → scan local cache for due slots
|
||||
if due slot found:
|
||||
confirmAgentStatus() → GET /calendar/agent/status
|
||||
if not busy → wakeAgent (via Dirigent moderator bot private channel)
|
||||
```
|
||||
|
||||
## Changes Required
|
||||
|
||||
### 1. Add Local Schedule Cache
|
||||
|
||||
New class `ScheduleCache`:
|
||||
```typescript
|
||||
class ScheduleCache {
|
||||
private slots: Map<string, CalendarSlotResponse>; // slotId → slot
|
||||
private lastSyncAt: Date | null;
|
||||
|
||||
async sync(bridge: CalendarBridgeClient): Promise<void>; // fetch today's full schedule
|
||||
getDueSlots(now: Date): CalendarSlotResponse[]; // scheduled_at <= now && NOT_STARTED/DEFERRED
|
||||
updateSlot(id: string, update: Partial<CalendarSlotResponse>): void; // local update
|
||||
getAll(): CalendarSlotResponse[];
|
||||
}
|
||||
```
|
||||
|
||||
### 2. Add CalendarBridgeClient.getDaySchedule()
|
||||
|
||||
New endpoint call:
|
||||
```typescript
|
||||
async getDaySchedule(date: string): Promise<CalendarSlotResponse[]>
|
||||
// GET /calendar/day?date=YYYY-MM-DD
|
||||
```
|
||||
|
||||
This fetches ALL slots for the day, not just pending ones. The existing `heartbeat()` only returns NOT_STARTED/DEFERRED.
|
||||
|
||||
### 3. Split Heartbeat into Sync + Check
|
||||
|
||||
**Replace** single `runHeartbeat()` with two intervals:
|
||||
|
||||
```typescript
|
||||
// Local schedule cache: { agentId → [slots] }
|
||||
const schedules: Map<string, CalendarSlotResponse[]> = new Map();
|
||||
// Sync: every 5 min — pull full schedule from backend
|
||||
this.syncInterval = setInterval(() => this.runSync(), 300_000);
|
||||
|
||||
// Check: every 30s — scan local cache for due slots
|
||||
this.checkInterval = setInterval(() => this.runCheck(), 30_000);
|
||||
```
|
||||
|
||||
### Sync Flow (every 5 min)
|
||||
`runSync()`:
|
||||
1. `bridge.getDaySchedule(today)` → update cache
|
||||
2. Still send heartbeat to keep backend informed of agent liveness
|
||||
|
||||
```
|
||||
1. GET /calendar/sync?claw_identifier=xxx
|
||||
- First call: server returns full { agentId → [slots] }
|
||||
- Subsequent: server returns diff since last sync
|
||||
2. Update local schedules map
|
||||
3. Scan schedules for due slots:
|
||||
for each agentId in schedules:
|
||||
if has slot where scheduled_at <= now && status == not_started:
|
||||
getAgentStatus(agentId, clawIdentifier) → busy?
|
||||
if not busy → wakeAgent(agentId)
|
||||
```
|
||||
`runCheck()`:
|
||||
1. `cache.getDueSlots(now)` → find due slots
|
||||
2. Filter out session-deferred slots
|
||||
3. If agent idle → select highest priority → execute
|
||||
|
||||
### Heartbeat (every 60s)
|
||||
### 4. Wakeup via Dirigent (future)
|
||||
|
||||
Simplified to liveness ping only:
|
||||
```
|
||||
POST /monitor/server/heartbeat
|
||||
claw_identifier: xxx
|
||||
→ server returns empty/ack
|
||||
```
|
||||
Change `wakeAgent()` to create a private Discord channel via Dirigent moderator bot instead of `api.spawn()`. This requires:
|
||||
- Access to Dirigent's moderator bot token or cross-plugin API
|
||||
- Creating a private channel with only the target agent
|
||||
- Posting the wakeup prompt as a message
|
||||
|
||||
No slot data in heartbeat response.
|
||||
|
||||
### Wake Flow
|
||||
|
||||
```
|
||||
dispatchInboundMessage:
|
||||
SessionKey: agent:{agentId}:hf-wakeup
|
||||
Body: "You have due slots. Follow the hf-wakeup workflow of skill hf-hangman-lab to proceed. Only reply WAKEUP_OK in this session."
|
||||
|
||||
Agent reads workflow → calls hf tools → sets own status to busy
|
||||
```
|
||||
|
||||
### Agent ID Resolution
|
||||
|
||||
- **Sync**: agentId comes from server response (dict keys)
|
||||
- **Wake**: agentId from local schedules dict key
|
||||
- **Tool calls by agent**: agentId from tool ctx (same as padded-cell)
|
||||
|
||||
## Backend API Changes Needed
|
||||
|
||||
### New: GET /calendar/sync
|
||||
|
||||
```
|
||||
GET /calendar/sync?claw_identifier=xxx
|
||||
Headers: X-Claw-Identifier
|
||||
|
||||
Response (first call):
|
||||
{
|
||||
"full": true,
|
||||
"schedules": {
|
||||
"developer": [slot1, slot2, ...],
|
||||
"operator": [slot3, ...]
|
||||
},
|
||||
"syncToken": "abc123"
|
||||
}
|
||||
|
||||
Response (subsequent, with ?since=abc123):
|
||||
{
|
||||
"full": false,
|
||||
"diff": [
|
||||
{ "op": "add", "agent": "developer", "slot": {...} },
|
||||
{ "op": "update", "agent": "developer", "slotId": 5, "patch": {...} },
|
||||
{ "op": "remove", "agent": "operator", "slotId": 3 }
|
||||
],
|
||||
"syncToken": "def456"
|
||||
}
|
||||
```
|
||||
|
||||
### Existing: POST /calendar/agent/status
|
||||
|
||||
Keep as-is but ensure it accepts agentId + clawIdentifier as params:
|
||||
```
|
||||
POST /calendar/agent/status
|
||||
{ agent_id, claw_identifier, status }
|
||||
```
|
||||
**For now:** Keep `api.spawn()` as the wakeup method. The Dirigent integration can be added later as it requires cross-plugin coordination.
|
||||
|
||||
## Implementation Order
|
||||
|
||||
1. Backend: Add /calendar/sync endpoint
|
||||
2. Plugin: Replace CalendarBridgeClient single-agent design with multi-agent
|
||||
3. Plugin: Replace CalendarScheduler with new sync+check loop
|
||||
4. Plugin: wakeAgent uses dispatchInboundMessage (done)
|
||||
5. Plugin: Tool handlers get agentId from ctx (like padded-cell)
|
||||
1. Add `ScheduleCache` class (new file: `plugin/calendar/schedule-cache.ts`)
|
||||
2. Add `getDaySchedule()` to `CalendarBridgeClient`
|
||||
3. Refactor `CalendarScheduler`:
|
||||
- Replace single interval with sync + check intervals
|
||||
- Use cache instead of heartbeat for slot discovery
|
||||
- Keep heartbeat for agent liveness reporting (reduced frequency)
|
||||
4. Update state persistence for new structure
|
||||
5. Keep existing wakeAgent/completion/abort/pause/resume tools unchanged
|
||||
|
||||
## Files to Change
|
||||
## Files to Modify
|
||||
|
||||
### Backend (HarborForge.Backend)
|
||||
- New route: `/calendar/sync`
|
||||
- New service: schedule diff tracking per claw_identifier
|
||||
| File | Changes |
|
||||
|------|---------|
|
||||
| `plugin/calendar/schedule-cache.ts` | New file |
|
||||
| `plugin/calendar/calendar-bridge.ts` | Add `getDaySchedule()` |
|
||||
| `plugin/calendar/scheduler.ts` | Refactor heartbeat → sync + check |
|
||||
| `plugin/calendar/index.ts` | Export new types |
|
||||
|
||||
### Plugin
|
||||
- `plugin/calendar/calendar-bridge.ts` — remove agentId binding, add sync()
|
||||
- `plugin/calendar/scheduler.ts` — rewrite to multi-agent sync+check
|
||||
- `plugin/calendar/schedule-cache.ts` — already exists, adapt to multi-agent
|
||||
- `plugin/index.ts` — update wakeAgent, getAgentStatus to accept agentId
|
||||
## Risk Assessment
|
||||
|
||||
- **Low risk:** ScheduleCache is additive, doesn't break existing behavior
|
||||
- **Medium risk:** Splitting heartbeat changes core scheduling logic
|
||||
- **Mitigation:** Keep `heartbeat()` method intact, use it for liveness reporting alongside new sync
|
||||
|
||||
@@ -29,7 +29,7 @@ import {
|
||||
CalendarSlotResponse,
|
||||
SlotAgentUpdate,
|
||||
SlotStatus,
|
||||
} from './types.js';
|
||||
} from './types';
|
||||
|
||||
export interface CalendarBridgeConfig {
|
||||
/** HarborForge backend base URL (e.g. "https://monitor.hangman-lab.top") */
|
||||
@@ -110,23 +110,6 @@ export class CalendarBridgeClient {
|
||||
return this.sendBoolean('PATCH', url, update);
|
||||
}
|
||||
|
||||
/**
|
||||
* Same as {@link updateSlot} but overrides the `X-Agent-ID` header for a
|
||||
* single call. Used by the multi-agent scheduler handle where the bridge
|
||||
* client is shared across agents and the constructor agentId is `'unused'`.
|
||||
*
|
||||
* Backend identifies the slot purely by `slotId`; the header is informational
|
||||
* for audit. Passing the calling agent's id keeps audit/log lines correct.
|
||||
*/
|
||||
async updateSlotAs(
|
||||
agentId: string,
|
||||
slotId: number,
|
||||
update: SlotAgentUpdate
|
||||
): Promise<boolean> {
|
||||
const url = `${this.baseUrl}/calendar/slots/${slotId}/agent-update`;
|
||||
return this.sendBooleanAs(agentId, 'PATCH', url, update);
|
||||
}
|
||||
|
||||
/**
|
||||
* Update a virtual (plan-generated) slot's status after agent execution.
|
||||
*
|
||||
@@ -212,48 +195,6 @@ export class CalendarBridgeClient {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sync today's schedules for all agents on this claw instance.
|
||||
*
|
||||
* Returns { agentId → slots[] } for all agents with matching claw_identifier.
|
||||
* This is the primary data source for the multi-agent schedule cache.
|
||||
*/
|
||||
async syncSchedules(): Promise<{ schedules: Record<string, any[]>; date: string } | null> {
|
||||
const url = `${this.baseUrl}/calendar/sync`;
|
||||
try {
|
||||
const response = await this.fetchJson<{ schedules: Record<string, any[]>; date: string }>(url, {
|
||||
method: 'GET',
|
||||
headers: {
|
||||
'X-Claw-Identifier': this.config.clawIdentifier,
|
||||
},
|
||||
});
|
||||
return response;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a specific agent's status.
|
||||
*
|
||||
* @param agentId The agent ID to query
|
||||
*/
|
||||
async getAgentStatus(agentId: string): Promise<string | null> {
|
||||
const url = `${this.baseUrl}/calendar/agent/status?agent_id=${encodeURIComponent(agentId)}`;
|
||||
try {
|
||||
const response = await this.fetchJson<{ status: string }>(url, {
|
||||
method: 'GET',
|
||||
headers: {
|
||||
'X-Agent-ID': agentId,
|
||||
'X-Claw-Identifier': this.config.clawIdentifier,
|
||||
},
|
||||
});
|
||||
return response?.status ?? null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Internal helpers
|
||||
// -------------------------------------------------------------------------
|
||||
@@ -281,15 +222,6 @@ export class CalendarBridgeClient {
|
||||
}
|
||||
|
||||
private async sendBoolean(method: 'POST' | 'PATCH', url: string, body: unknown): Promise<boolean> {
|
||||
return this.sendBooleanAs(this.config.agentId, method, url, body);
|
||||
}
|
||||
|
||||
private async sendBooleanAs(
|
||||
agentId: string,
|
||||
method: 'POST' | 'PATCH',
|
||||
url: string,
|
||||
body: unknown
|
||||
): Promise<boolean> {
|
||||
const controller = new AbortController();
|
||||
const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
|
||||
|
||||
@@ -298,7 +230,7 @@ export class CalendarBridgeClient {
|
||||
method,
|
||||
headers: {
|
||||
'Content-Type': 'application/json',
|
||||
'X-Agent-ID': agentId,
|
||||
'X-Agent-ID': this.config.agentId,
|
||||
'X-Claw-Identifier': this.config.clawIdentifier,
|
||||
},
|
||||
body: JSON.stringify(body),
|
||||
@@ -318,7 +250,7 @@ export class CalendarBridgeClient {
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
import { hostname } from 'os';
|
||||
import { getPluginConfig } from '../core/config.js';
|
||||
import { getPluginConfig } from '../core/config';
|
||||
|
||||
export interface CalendarPluginConfig {
|
||||
/** Backend URL for calendar API (overrides monitor backendUrl) */
|
||||
|
||||
172
plugin/calendar/discord-wakeup.ts
Normal file
172
plugin/calendar/discord-wakeup.ts
Normal file
@@ -0,0 +1,172 @@
|
||||
/**
|
||||
* Discord-based agent wakeup: create a private channel and send a wakeup message.
|
||||
*
|
||||
* If Dirigent is detected (via globalThis.__dirigent), creates a work-type channel.
|
||||
* Otherwise, creates a plain private Discord channel.
|
||||
*/
|
||||
|
||||
const DISCORD_API = 'https://discord.com/api/v10';
|
||||
|
||||
interface WakeupConfig {
|
||||
botToken: string;
|
||||
guildId: string;
|
||||
agentDiscordId?: string;
|
||||
agentId: string;
|
||||
message: string;
|
||||
logger: {
|
||||
info: (...args: any[]) => void;
|
||||
warn: (...args: any[]) => void;
|
||||
error: (...args: any[]) => void;
|
||||
};
|
||||
}
|
||||
|
||||
interface DirigentApi {
|
||||
createWorkChannel?: (params: {
|
||||
guildId: string;
|
||||
name: string;
|
||||
agentDiscordId: string;
|
||||
}) => Promise<string>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get bot user ID from token (decode JWT-like Discord token).
|
||||
*/
|
||||
function getBotUserIdFromToken(token: string): string | null {
|
||||
try {
|
||||
const base64 = token.split('.')[0];
|
||||
const decoded = Buffer.from(base64, 'base64').toString('utf8');
|
||||
return decoded || null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a private Discord channel visible only to the target agent and bot.
|
||||
*/
|
||||
async function createPrivateChannel(
|
||||
token: string,
|
||||
guildId: string,
|
||||
name: string,
|
||||
memberIds: string[],
|
||||
logger: WakeupConfig['logger']
|
||||
): Promise<string | null> {
|
||||
const botId = getBotUserIdFromToken(token);
|
||||
|
||||
// Permission overwrites: deny @everyone, allow specific members
|
||||
const permissionOverwrites = [
|
||||
{ id: guildId, type: 0, deny: '1024' }, // deny @everyone view
|
||||
...memberIds.map(id => ({ id, type: 1, allow: '1024' })), // allow members view
|
||||
...(botId ? [{ id: botId, type: 1, allow: '1024' }] : []),
|
||||
];
|
||||
|
||||
try {
|
||||
const res = await fetch(`${DISCORD_API}/guilds/${guildId}/channels`, {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Authorization': `Bot ${token}`,
|
||||
'Content-Type': 'application/json',
|
||||
},
|
||||
body: JSON.stringify({
|
||||
name,
|
||||
type: 0, // text channel
|
||||
permission_overwrites: permissionOverwrites,
|
||||
}),
|
||||
});
|
||||
|
||||
if (!res.ok) {
|
||||
logger.warn(`Discord channel creation failed: ${res.status} ${await res.text()}`);
|
||||
return null;
|
||||
}
|
||||
|
||||
const data = await res.json() as { id: string };
|
||||
return data.id;
|
||||
} catch (err) {
|
||||
logger.error(`Discord channel creation error: ${String(err)}`);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Send a message to a Discord channel.
|
||||
*/
|
||||
async function sendMessage(
|
||||
token: string,
|
||||
channelId: string,
|
||||
content: string,
|
||||
logger: WakeupConfig['logger']
|
||||
): Promise<boolean> {
|
||||
try {
|
||||
const res = await fetch(`${DISCORD_API}/channels/${channelId}/messages`, {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Authorization': `Bot ${token}`,
|
||||
'Content-Type': 'application/json',
|
||||
},
|
||||
body: JSON.stringify({ content }),
|
||||
});
|
||||
|
||||
if (!res.ok) {
|
||||
logger.warn(`Discord message send failed: ${res.status}`);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
} catch (err) {
|
||||
logger.error(`Discord message send error: ${String(err)}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Wake an agent via Discord: create a private channel and send the wakeup message.
|
||||
*/
|
||||
export async function wakeAgentViaDiscord(config: WakeupConfig): Promise<boolean> {
|
||||
const { botToken, guildId, agentDiscordId, agentId, message, logger } = config;
|
||||
|
||||
if (!botToken || !guildId) {
|
||||
logger.warn('Discord wakeup: botToken or guildId not configured');
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check if Dirigent is available for work channel creation
|
||||
const dirigent = (globalThis as Record<string, unknown>)['__dirigent'] as DirigentApi | undefined;
|
||||
|
||||
let channelId: string | null = null;
|
||||
const channelName = `hf-wakeup-${agentId}-${Date.now()}`;
|
||||
|
||||
if (dirigent?.createWorkChannel && agentDiscordId) {
|
||||
// Use Dirigent to create a work-type channel (with turn management)
|
||||
try {
|
||||
channelId = await dirigent.createWorkChannel({
|
||||
guildId,
|
||||
name: channelName,
|
||||
agentDiscordId,
|
||||
});
|
||||
logger.info(`Wakeup channel created via Dirigent: ${channelId}`);
|
||||
} catch (err) {
|
||||
logger.warn(`Dirigent work channel creation failed, falling back to plain channel: ${String(err)}`);
|
||||
}
|
||||
}
|
||||
|
||||
if (!channelId) {
|
||||
// Fallback: create a plain private Discord channel
|
||||
const memberIds = agentDiscordId ? [agentDiscordId] : [];
|
||||
channelId = await createPrivateChannel(botToken, guildId, channelName, memberIds, logger);
|
||||
if (channelId) {
|
||||
logger.info(`Wakeup channel created (plain): ${channelId}`);
|
||||
}
|
||||
}
|
||||
|
||||
if (!channelId) {
|
||||
logger.error('Failed to create wakeup channel');
|
||||
return false;
|
||||
}
|
||||
|
||||
// Send the wakeup message
|
||||
const sent = await sendMessage(botToken, channelId, message, logger);
|
||||
if (sent) {
|
||||
logger.info(`Wakeup message sent to ${channelId} for agent ${agentId}`);
|
||||
}
|
||||
|
||||
return sent;
|
||||
}
|
||||
@@ -13,7 +13,7 @@
|
||||
* • AgentWakeContext — context passed to agent when waking
|
||||
*
|
||||
* Usage in plugin/index.ts:
|
||||
* import { createCalendarBridgeClient, createCalendarScheduler } from './calendar.js';
|
||||
* import { createCalendarBridgeClient, createCalendarScheduler } from './calendar';
|
||||
*
|
||||
* const agentId = process.env.AGENT_ID || 'unknown';
|
||||
* const calendar = createCalendarBridgeClient(api, 'https://monitor.hangman-lab.top', agentId);
|
||||
@@ -28,7 +28,8 @@
|
||||
* scheduler.start();
|
||||
*/
|
||||
|
||||
export * from './types.js';
|
||||
export * from './calendar-bridge.js';
|
||||
export * from './scheduler.js';
|
||||
export * from './schedule-cache.js';
|
||||
export * from './types';
|
||||
export * from './calendar-bridge';
|
||||
export * from './scheduler';
|
||||
export * from './schedule-cache';
|
||||
export * from './discord-wakeup';
|
||||
|
||||
@@ -1,240 +0,0 @@
|
||||
/**
|
||||
* MultiAgentSchedulerHandle — runtime façade that backs the public
|
||||
* `harborforge_calendar_*` tools when the plugin runs in multi-agent sync
|
||||
* mode.
|
||||
*
|
||||
* Background
|
||||
* ----------
|
||||
* The old single-agent path used `CalendarScheduler` which kept a "current
|
||||
* slot" cursor and exposed `isRunning() / completeCurrentSlot() / abortCurrentSlot() / …`.
|
||||
* In multi-agent mode the plugin doesn't own a single cursor — one plugin
|
||||
* instance services every agent on the claw — so the previous code stubbed the
|
||||
* `calendarScheduler` variable to `{ stop() }`. That made every tool fail
|
||||
* with `calendarScheduler.<method> is not a function`.
|
||||
*
|
||||
* This handle restores the same surface area (`isRunning / getCurrentSlot /
|
||||
* completeCurrentSlot / …`) but resolves the "current slot" per caller via
|
||||
* the agentId/sessionKey supplied by the OpenClaw tool-factory context. The
|
||||
* scheduler records the slot it just dispatched to each agent in
|
||||
* {@link recordWoken}; the tool resolves the caller, looks up the last woken
|
||||
* slot, and PATCHes the backend via the shared bridge.
|
||||
*
|
||||
* Tools must pass the calling agentId (from `OpenClawPluginToolContext.agentId`)
|
||||
* into every method. The handle does not consult `process.env.AGENT_ID` — the
|
||||
* gateway sets that to the host's primary agent which is meaningless in
|
||||
* multi-agent mode.
|
||||
*/
|
||||
|
||||
import type { CalendarBridgeClient } from './calendar-bridge.js';
|
||||
import type { MultiAgentScheduleCache, CachedSlot } from './schedule-cache.js';
|
||||
import { SlotStatus } from './types.js';
|
||||
|
||||
export interface MultiAgentSchedulerHandleParams {
|
||||
bridge: CalendarBridgeClient;
|
||||
cache: MultiAgentScheduleCache;
|
||||
/** setInterval handles cleared on stop() */
|
||||
syncHandle: ReturnType<typeof setInterval>;
|
||||
checkHandle: ReturnType<typeof setInterval>;
|
||||
logger: {
|
||||
info: (...args: unknown[]) => void;
|
||||
warn: (...args: unknown[]) => void;
|
||||
error: (...args: unknown[]) => void;
|
||||
};
|
||||
}
|
||||
|
||||
/** Last slot we dispatched to an agent. Used as the implicit "current slot". */
|
||||
export interface WokenSlot {
|
||||
agentId: string;
|
||||
slotId: number | null;
|
||||
virtualId: string | null;
|
||||
scheduledAt: string | null;
|
||||
slotType: string | null;
|
||||
estimatedDuration: number | null;
|
||||
wokenAt: string;
|
||||
}
|
||||
|
||||
/** Public surface — mirrors the relevant subset of the old single-agent scheduler. */
|
||||
export class MultiAgentSchedulerHandle {
|
||||
private readonly bridge: CalendarBridgeClient;
|
||||
private readonly cache: MultiAgentScheduleCache;
|
||||
private readonly syncHandle: ReturnType<typeof setInterval>;
|
||||
private readonly checkHandle: ReturnType<typeof setInterval>;
|
||||
private readonly logger: MultiAgentSchedulerHandleParams['logger'];
|
||||
private readonly woken: Map<string, WokenSlot> = new Map();
|
||||
private stopped = false;
|
||||
|
||||
constructor(params: MultiAgentSchedulerHandleParams) {
|
||||
this.bridge = params.bridge;
|
||||
this.cache = params.cache;
|
||||
this.syncHandle = params.syncHandle;
|
||||
this.checkHandle = params.checkHandle;
|
||||
this.logger = params.logger;
|
||||
}
|
||||
|
||||
// ---------- lifecycle ----------
|
||||
|
||||
/** True while the sync/check intervals are still ticking. */
|
||||
isRunning(): boolean {
|
||||
return !this.stopped;
|
||||
}
|
||||
|
||||
/** Always false in multi-agent mode — there is no per-instance work queue. */
|
||||
isProcessing(): boolean {
|
||||
return false;
|
||||
}
|
||||
|
||||
stop(): void {
|
||||
if (this.stopped) return;
|
||||
this.stopped = true;
|
||||
clearInterval(this.syncHandle);
|
||||
clearInterval(this.checkHandle);
|
||||
this.logger.info('Calendar scheduler stopped (multi-agent mode)');
|
||||
}
|
||||
|
||||
// ---------- wake bookkeeping ----------
|
||||
|
||||
/** Record that we just dispatched a slot to `agentId`. */
|
||||
recordWoken(agentId: string, slot: CachedSlot): void {
|
||||
this.woken.set(agentId, {
|
||||
agentId,
|
||||
slotId: typeof slot.id === 'number' ? slot.id : null,
|
||||
virtualId: typeof slot.virtual_id === 'string' ? slot.virtual_id : null,
|
||||
scheduledAt: typeof slot.scheduled_at === 'string' ? slot.scheduled_at : null,
|
||||
slotType: typeof slot.slot_type === 'string' ? slot.slot_type : null,
|
||||
estimatedDuration:
|
||||
typeof slot.estimated_duration === 'number' ? slot.estimated_duration : null,
|
||||
wokenAt: new Date().toISOString(),
|
||||
});
|
||||
}
|
||||
|
||||
// ---------- per-agent reads ----------
|
||||
|
||||
/**
|
||||
* The slot most recently dispatched to `agentId`, or null if we never woke
|
||||
* them (e.g. tool called outside a wakeup). Callers can fall back to
|
||||
* scanning {@link cachedSlotsFor} for `not_started`/`deferred` slots if they
|
||||
* want a heuristic "current".
|
||||
*/
|
||||
getWokenSlot(agentId: string | null | undefined): WokenSlot | null {
|
||||
if (!agentId) return null;
|
||||
return this.woken.get(agentId) ?? null;
|
||||
}
|
||||
|
||||
/** Today's cached slots for an agent (whatever runSync last pulled). */
|
||||
cachedSlotsFor(agentId: string | null | undefined): CachedSlot[] {
|
||||
if (!agentId) return [];
|
||||
return this.cache.getAgentSlots(agentId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implicit "current" slot: the last woken slot if we know about it,
|
||||
* otherwise the highest-priority `not_started`/`deferred`/`ongoing` cached
|
||||
* slot for the agent (so a tool called between sync windows still finds
|
||||
* something sensible).
|
||||
*/
|
||||
resolveCurrentSlot(agentId: string | null | undefined): WokenSlot | null {
|
||||
const woken = this.getWokenSlot(agentId);
|
||||
if (woken) return woken;
|
||||
if (!agentId) return null;
|
||||
const slots = this.cache.getAgentSlots(agentId)
|
||||
.filter((s) => s.status === 'not_started' || s.status === 'deferred' || s.status === 'ongoing')
|
||||
.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
|
||||
const top = slots[0];
|
||||
if (!top) return null;
|
||||
return {
|
||||
agentId,
|
||||
slotId: typeof top.id === 'number' ? top.id : null,
|
||||
virtualId: typeof top.virtual_id === 'string' ? top.virtual_id : null,
|
||||
scheduledAt: typeof top.scheduled_at === 'string' ? top.scheduled_at : null,
|
||||
slotType: typeof top.slot_type === 'string' ? top.slot_type : null,
|
||||
estimatedDuration:
|
||||
typeof top.estimated_duration === 'number' ? top.estimated_duration : null,
|
||||
wokenAt: 'inferred-from-cache',
|
||||
};
|
||||
}
|
||||
|
||||
// ---------- per-agent writes ----------
|
||||
|
||||
async completeSlot(agentId: string, actualDurationMinutes: number): Promise<SlotMutationResult> {
|
||||
return this.transition(agentId, SlotStatus.FINISHED, { actual_duration: actualDurationMinutes });
|
||||
}
|
||||
|
||||
async abortSlot(agentId: string, reason?: string): Promise<SlotMutationResult> {
|
||||
if (reason) this.logger.info(`Aborting slot for ${agentId}: ${reason}`);
|
||||
return this.transition(agentId, SlotStatus.ABORTED);
|
||||
}
|
||||
|
||||
async pauseSlot(agentId: string): Promise<SlotMutationResult> {
|
||||
return this.transition(agentId, SlotStatus.PAUSED);
|
||||
}
|
||||
|
||||
/** Resume puts the slot back into `ongoing` so it isn't picked up as `not_started`. */
|
||||
async resumeSlot(agentId: string): Promise<SlotMutationResult> {
|
||||
return this.transition(agentId, SlotStatus.ONGOING);
|
||||
}
|
||||
|
||||
private async transition(
|
||||
agentId: string,
|
||||
status: SlotStatus,
|
||||
extra: { actual_duration?: number } = {}
|
||||
): Promise<SlotMutationResult> {
|
||||
const slot = this.resolveCurrentSlot(agentId);
|
||||
if (!slot) {
|
||||
return { ok: false, error: `No tracked slot for agent '${agentId}'` };
|
||||
}
|
||||
if (slot.slotId == null && slot.virtualId == null) {
|
||||
return { ok: false, error: 'Resolved slot has neither id nor virtual_id' };
|
||||
}
|
||||
const update = { status, ...extra };
|
||||
try {
|
||||
if (slot.slotId != null) {
|
||||
const ok = await this.bridge.updateSlotAs(agentId, slot.slotId, update);
|
||||
if (!ok) return { ok: false, error: `Backend rejected slot ${slot.slotId} → ${status}` };
|
||||
// Clear the wake cursor only on terminal transitions so re-wakes don't
|
||||
// re-trigger the same slot mutation.
|
||||
if (status === SlotStatus.FINISHED || status === SlotStatus.ABORTED) {
|
||||
this.woken.delete(agentId);
|
||||
}
|
||||
return { ok: true, slot, status };
|
||||
}
|
||||
// virtual slot path: bridge has updateVirtualSlot
|
||||
const materialised = await this.bridge.updateVirtualSlot(slot.virtualId!, update);
|
||||
if (!materialised) {
|
||||
return { ok: false, error: `Backend rejected virtual slot ${slot.virtualId}` };
|
||||
}
|
||||
if (status === SlotStatus.FINISHED || status === SlotStatus.ABORTED) {
|
||||
this.woken.delete(agentId);
|
||||
}
|
||||
return { ok: true, slot, status, materialised };
|
||||
} catch (err: unknown) {
|
||||
const msg = (err as { message?: string } | undefined)?.message ?? String(err);
|
||||
return { ok: false, error: msg };
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- gateway-restart parity (no-op in multi-agent mode) ----------
|
||||
|
||||
/** Multi-agent scheduler does not persist a `ScheduledGatewayRestart` flag. */
|
||||
isRestartPending(): boolean {
|
||||
return false;
|
||||
}
|
||||
getStateFilePath(): string | null {
|
||||
return null;
|
||||
}
|
||||
getState(): { mode: 'multi-agent'; agents: number; lastWoken: WokenSlot[] } {
|
||||
return {
|
||||
mode: 'multi-agent',
|
||||
agents: this.cache.getStatus().agentCount,
|
||||
lastWoken: Array.from(this.woken.values()),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
export interface SlotMutationResult {
|
||||
ok: boolean;
|
||||
error?: string;
|
||||
status?: SlotStatus;
|
||||
slot?: WokenSlot;
|
||||
/** Present only when a virtual slot was materialised. */
|
||||
materialised?: unknown;
|
||||
}
|
||||
@@ -1,97 +1,105 @@
|
||||
/**
|
||||
* Multi-agent local schedule cache.
|
||||
*
|
||||
* Maintains today's schedule for all agents on this claw instance.
|
||||
* Synced periodically from HF backend via /calendar/sync endpoint.
|
||||
* Local cache of today's calendar schedule.
|
||||
* Synced periodically from HF backend, checked locally for due slots.
|
||||
*/
|
||||
|
||||
export interface CachedSlot {
|
||||
id: number | null;
|
||||
virtual_id: string | null;
|
||||
slot_type: string;
|
||||
estimated_duration: number;
|
||||
scheduled_at: string;
|
||||
status: string;
|
||||
priority: number;
|
||||
event_type: string | null;
|
||||
event_data: Record<string, unknown> | null;
|
||||
[key: string]: unknown;
|
||||
}
|
||||
import type { CalendarSlotResponse } from "./types.js";
|
||||
|
||||
export class MultiAgentScheduleCache {
|
||||
/** { agentId → slots[] } */
|
||||
private schedules: Map<string, CachedSlot[]> = new Map();
|
||||
export class ScheduleCache {
|
||||
private slots: Map<string, CalendarSlotResponse> = new Map();
|
||||
private lastSyncAt: Date | null = null;
|
||||
private cachedDate: string | null = null;
|
||||
private cachedDate: string | null = null; // YYYY-MM-DD
|
||||
|
||||
/**
|
||||
* Replace cache with data from /calendar/sync response.
|
||||
* Replace the cache with a fresh schedule from backend.
|
||||
*/
|
||||
sync(date: string, schedules: Record<string, CachedSlot[]>): void {
|
||||
sync(date: string, slots: CalendarSlotResponse[]): void {
|
||||
// If date changed, clear old data
|
||||
if (this.cachedDate !== date) {
|
||||
this.schedules.clear();
|
||||
this.slots.clear();
|
||||
}
|
||||
this.cachedDate = date;
|
||||
|
||||
for (const [agentId, slots] of Object.entries(schedules)) {
|
||||
this.schedules.set(agentId, slots);
|
||||
// Merge: update existing slots, add new ones
|
||||
const incomingIds = new Set<string>();
|
||||
for (const slot of slots) {
|
||||
const id = this.getSlotId(slot);
|
||||
incomingIds.add(id);
|
||||
this.slots.set(id, slot);
|
||||
}
|
||||
|
||||
// Remove slots that no longer exist on backend (cancelled etc.)
|
||||
for (const id of this.slots.keys()) {
|
||||
if (!incomingIds.has(id)) {
|
||||
this.slots.delete(id);
|
||||
}
|
||||
}
|
||||
|
||||
this.lastSyncAt = new Date();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get agents that have due (overdue or current) slots.
|
||||
* Returns [agentId, dueSlots[]] pairs.
|
||||
* Get slots that are due (scheduled_at <= now) and still pending.
|
||||
*/
|
||||
getAgentsWithDueSlots(now: Date): Array<{ agentId: string; slots: CachedSlot[] }> {
|
||||
const results: Array<{ agentId: string; slots: CachedSlot[] }> = [];
|
||||
getDueSlots(now: Date): CalendarSlotResponse[] {
|
||||
const results: CalendarSlotResponse[] = [];
|
||||
for (const slot of this.slots.values()) {
|
||||
if (slot.status !== "not_started" && slot.status !== "deferred") continue;
|
||||
if (!slot.scheduled_at) continue;
|
||||
|
||||
for (const [agentId, slots] of this.schedules) {
|
||||
const due = slots.filter((s) => {
|
||||
if (s.status !== 'not_started' && s.status !== 'deferred') return false;
|
||||
const scheduledAt = this.parseScheduledTime(s.scheduled_at);
|
||||
return scheduledAt !== null && scheduledAt <= now;
|
||||
});
|
||||
|
||||
if (due.length > 0) {
|
||||
// Sort by priority descending
|
||||
due.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
|
||||
results.push({ agentId, slots: due });
|
||||
const scheduledAt = this.parseScheduledTime(slot.scheduled_at);
|
||||
if (scheduledAt && scheduledAt <= now) {
|
||||
results.push(slot);
|
||||
}
|
||||
}
|
||||
// Sort by priority descending
|
||||
results.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
|
||||
return results;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all agent IDs in the cache.
|
||||
* Update a slot locally (e.g., after status change).
|
||||
*/
|
||||
getAgentIds(): string[] {
|
||||
return Array.from(this.schedules.keys());
|
||||
updateSlot(slotId: string, update: Partial<CalendarSlotResponse>): void {
|
||||
const existing = this.slots.get(slotId);
|
||||
if (existing) {
|
||||
this.slots.set(slotId, { ...existing, ...update });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get slots for a specific agent.
|
||||
* Remove a slot from cache.
|
||||
*/
|
||||
getAgentSlots(agentId: string): CachedSlot[] {
|
||||
return this.schedules.get(agentId) ?? [];
|
||||
removeSlot(slotId: string): void {
|
||||
this.slots.delete(slotId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cache status for debugging.
|
||||
* Get all cached slots.
|
||||
*/
|
||||
getStatus(): { agentCount: number; totalSlots: number; lastSyncAt: string | null; cachedDate: string | null } {
|
||||
let totalSlots = 0;
|
||||
for (const slots of this.schedules.values()) totalSlots += slots.length;
|
||||
getAll(): CalendarSlotResponse[] {
|
||||
return Array.from(this.slots.values());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cache metadata.
|
||||
*/
|
||||
getStatus(): { slotCount: number; lastSyncAt: string | null; cachedDate: string | null } {
|
||||
return {
|
||||
agentCount: this.schedules.size,
|
||||
totalSlots,
|
||||
slotCount: this.slots.size,
|
||||
lastSyncAt: this.lastSyncAt?.toISOString() ?? null,
|
||||
cachedDate: this.cachedDate,
|
||||
};
|
||||
}
|
||||
|
||||
private getSlotId(slot: CalendarSlotResponse): string {
|
||||
return slot.virtual_id ?? String(slot.id);
|
||||
}
|
||||
|
||||
private parseScheduledTime(scheduledAt: string): Date | null {
|
||||
// scheduled_at can be "HH:MM:SS" (time only) or full ISO
|
||||
if (/^\d{2}:\d{2}(:\d{2})?$/.test(scheduledAt)) {
|
||||
// Time-only: combine with cached date
|
||||
if (!this.cachedDate) return null;
|
||||
return new Date(`${this.cachedDate}T${scheduledAt}Z`);
|
||||
}
|
||||
|
||||
@@ -18,7 +18,8 @@
|
||||
|
||||
import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
|
||||
import { join, dirname } from 'path';
|
||||
import { CalendarBridgeClient } from './calendar-bridge.js';
|
||||
import { CalendarBridgeClient } from './calendar-bridge';
|
||||
import { ScheduleCache } from './schedule-cache';
|
||||
import {
|
||||
CalendarSlotResponse,
|
||||
SlotStatus,
|
||||
@@ -26,7 +27,7 @@ import {
|
||||
SlotAgentUpdate,
|
||||
CalendarEventDataJob,
|
||||
CalendarEventDataSystemEvent,
|
||||
} from './types.js';
|
||||
} from './types';
|
||||
|
||||
export interface CalendarSchedulerConfig {
|
||||
/** Calendar bridge client for backend communication */
|
||||
@@ -44,6 +45,8 @@ export interface CalendarSchedulerConfig {
|
||||
};
|
||||
/** Heartbeat interval in milliseconds (default: 60000) */
|
||||
heartbeatIntervalMs?: number;
|
||||
/** Schedule sync interval in milliseconds (default: 300000 = 5 min) */
|
||||
syncIntervalMs?: number;
|
||||
/** Enable verbose debug logging */
|
||||
debug?: boolean;
|
||||
/** Directory for state persistence (default: plugin data dir) */
|
||||
@@ -95,8 +98,10 @@ interface SchedulerState {
|
||||
currentSlot: CalendarSlotResponse | null;
|
||||
/** Last heartbeat timestamp */
|
||||
lastHeartbeatAt: Date | null;
|
||||
/** Interval handle for cleanup */
|
||||
/** Heartbeat interval handle */
|
||||
intervalHandle: ReturnType<typeof setInterval> | null;
|
||||
/** Schedule sync interval handle */
|
||||
syncIntervalHandle: ReturnType<typeof setInterval> | null;
|
||||
/** Set of slot IDs that have been deferred in current session */
|
||||
deferredSlotIds: Set<string>;
|
||||
/** Whether agent is currently processing a slot */
|
||||
@@ -117,10 +122,13 @@ export class CalendarScheduler {
|
||||
private config: Required<CalendarSchedulerConfig>;
|
||||
private state: SchedulerState;
|
||||
private stateFilePath: string;
|
||||
/** Local cache of today's full schedule, synced periodically from backend */
|
||||
private scheduleCache: ScheduleCache = new ScheduleCache();
|
||||
|
||||
constructor(config: CalendarSchedulerConfig) {
|
||||
this.config = {
|
||||
heartbeatIntervalMs: 60000, // 1 minute default
|
||||
syncIntervalMs: 300_000, // 5 minutes default
|
||||
debug: false,
|
||||
stateDir: this.getDefaultStateDir(),
|
||||
...config,
|
||||
@@ -133,6 +141,7 @@ export class CalendarScheduler {
|
||||
currentSlot: null,
|
||||
lastHeartbeatAt: null,
|
||||
intervalHandle: null,
|
||||
syncIntervalHandle: null,
|
||||
deferredSlotIds: new Set(),
|
||||
isProcessing: false,
|
||||
isRestartPending: false,
|
||||
@@ -327,14 +336,21 @@ export class CalendarScheduler {
|
||||
this.state.isRestartPending = false;
|
||||
this.config.logger.info('Calendar scheduler started');
|
||||
|
||||
// Run initial heartbeat immediately
|
||||
// Run initial sync + heartbeat immediately
|
||||
this.runSync();
|
||||
this.runHeartbeat();
|
||||
|
||||
// Schedule periodic heartbeats
|
||||
// Schedule periodic heartbeats (slot execution checks)
|
||||
this.state.intervalHandle = setInterval(
|
||||
() => this.runHeartbeat(),
|
||||
this.config.heartbeatIntervalMs
|
||||
);
|
||||
|
||||
// Schedule periodic schedule sync (full day schedule refresh)
|
||||
this.state.syncIntervalHandle = setInterval(
|
||||
() => this.runSync(),
|
||||
this.config.syncIntervalMs
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -348,10 +364,41 @@ export class CalendarScheduler {
|
||||
clearInterval(this.state.intervalHandle);
|
||||
this.state.intervalHandle = null;
|
||||
}
|
||||
if (this.state.syncIntervalHandle) {
|
||||
clearInterval(this.state.syncIntervalHandle);
|
||||
this.state.syncIntervalHandle = null;
|
||||
}
|
||||
|
||||
this.config.logger.info('Calendar scheduler stopped');
|
||||
}
|
||||
|
||||
/**
|
||||
* Sync today's full schedule from backend into local cache.
|
||||
* Runs every syncIntervalMs (default: 5 min).
|
||||
* Catches new slots assigned by other agents or the manager.
|
||||
*/
|
||||
async runSync(): Promise<void> {
|
||||
if (!this.state.isRunning || this.state.isRestartPending) return;
|
||||
|
||||
const today = new Date().toISOString().slice(0, 10);
|
||||
try {
|
||||
const slots = await this.config.bridge.getDaySchedule(today);
|
||||
if (slots) {
|
||||
this.scheduleCache.sync(today, slots);
|
||||
this.logDebug(`Schedule synced: ${slots.length} slots for ${today}`);
|
||||
}
|
||||
} catch (err) {
|
||||
this.config.logger.warn(`Schedule sync failed: ${String(err)}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the local schedule cache (for status reporting / tools).
|
||||
*/
|
||||
getScheduleCache(): ScheduleCache {
|
||||
return this.scheduleCache;
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a single heartbeat cycle.
|
||||
* Fetches pending slots and handles execution logic.
|
||||
@@ -611,13 +658,11 @@ Task Code: ${code}
|
||||
Estimated Duration: ${duration} minutes
|
||||
Slot Type: ${slot.slot_type}
|
||||
Priority: ${slot.priority}
|
||||
Working Sessions: ${jobData.working_sessions?.join(', ') || 'none recorded'}
|
||||
|
||||
Please focus on this task for the allocated time. When you finish or need to pause,
|
||||
report your progress back to the calendar system.
|
||||
|
||||
Working sessions: ${jobData.working_sessions?.join(', ') || 'none recorded'}
|
||||
|
||||
Start working on ${code} now.`;
|
||||
Follow the daily-routine skill's task-handson workflow to execute this task.
|
||||
Use harborforge_calendar_complete when finished, or harborforge_calendar_pause to pause.
|
||||
Before going idle, check for overdue slots as described in the slot-complete workflow.`;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -630,19 +675,15 @@ Start working on ${code} now.`;
|
||||
switch (sysData.event) {
|
||||
case 'ScheduleToday':
|
||||
return `System Event: Schedule Today
|
||||
|
||||
Please review today's calendar and schedule any pending tasks or planning activities.
|
||||
Estimated time: ${slot.estimated_duration} minutes.
|
||||
|
||||
Check your calendar and plan the day's work.`;
|
||||
Follow the daily-routine skill's plan-schedule workflow to plan today's work.`;
|
||||
|
||||
case 'SummaryToday':
|
||||
return `System Event: Daily Summary
|
||||
|
||||
Please provide a summary of today's activities and progress.
|
||||
Estimated time: ${slot.estimated_duration} minutes.
|
||||
|
||||
Review what was accomplished and prepare end-of-day notes.`;
|
||||
Review today's completed, deferred, and abandoned slots. Write a summary to your daily note (memory/YYYY-MM-DD.md).`;
|
||||
|
||||
case 'ScheduledGatewayRestart':
|
||||
return `System Event: Scheduled Gateway Restart
|
||||
|
||||
@@ -1,3 +1,8 @@
|
||||
import { execFile } from 'child_process';
|
||||
import { promisify } from 'util';
|
||||
|
||||
const execFileAsync = promisify(execFile);
|
||||
|
||||
export interface OpenClawAgentInfo {
|
||||
name: string;
|
||||
isDefault?: boolean;
|
||||
@@ -9,38 +14,70 @@ export interface OpenClawAgentInfo {
|
||||
routing?: string;
|
||||
}
|
||||
|
||||
export async function listOpenClawAgents(_logger?: { debug?: (...args: any[]) => void; warn?: (...args: any[]) => void }): Promise<OpenClawAgentInfo[]> {
|
||||
return [];
|
||||
export async function listOpenClawAgents(logger?: { debug?: (...args: any[]) => void; warn?: (...args: any[]) => void }): Promise<OpenClawAgentInfo[]> {
|
||||
try {
|
||||
const { stdout } = await execFileAsync('openclaw', ['agents', 'list'], {
|
||||
timeout: 15000,
|
||||
maxBuffer: 1024 * 1024,
|
||||
});
|
||||
return parseOpenClawAgents(stdout);
|
||||
} catch (err) {
|
||||
logger?.warn?.('Failed to run `openclaw agents list`', err);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
export function parseOpenClawAgents(text: string): OpenClawAgentInfo[] {
|
||||
const lines = text.split(/\r?\n/);
|
||||
const out: OpenClawAgentInfo[] = [];
|
||||
let current: OpenClawAgentInfo | null = null;
|
||||
const push = () => { if (current) out.push(current); current = null; };
|
||||
|
||||
const push = () => {
|
||||
if (current) out.push(current);
|
||||
current = null;
|
||||
};
|
||||
|
||||
for (const raw of lines) {
|
||||
const line = raw.trimEnd();
|
||||
if (!line.trim() || line.startsWith("Agents:") || line.startsWith("Routing rules map") || line.startsWith("Channel status reflects")) continue;
|
||||
if (line.startsWith("- ")) {
|
||||
if (!line.trim() || line.startsWith('Agents:') || line.startsWith('Routing rules map') || line.startsWith('Channel status reflects')) continue;
|
||||
if (line.startsWith('- ')) {
|
||||
push();
|
||||
const m = line.match(/^-\s+(.+?)(?:\s+\((default)\))?$/);
|
||||
current = { name: m?.[1] || line.slice(2).trim(), isDefault: m?.[2] === "default" };
|
||||
current = {
|
||||
name: m?.[1] || line.slice(2).trim(),
|
||||
isDefault: m?.[2] === 'default',
|
||||
};
|
||||
continue;
|
||||
}
|
||||
if (!current) continue;
|
||||
const trimmed = line.trim();
|
||||
const idx = trimmed.indexOf(":");
|
||||
const idx = trimmed.indexOf(':');
|
||||
if (idx === -1) continue;
|
||||
const key = trimmed.slice(0, idx).trim();
|
||||
const value = trimmed.slice(idx + 1).trim();
|
||||
switch (key) {
|
||||
case "Identity": current.identity = value; break;
|
||||
case "Workspace": current.workspace = value; break;
|
||||
case "Agent dir": current.agentDir = value; break;
|
||||
case "Model": current.model = value; break;
|
||||
case "Routing rules": { const n = Number(value); current.routingRules = Number.isFinite(n) ? n : undefined; break; }
|
||||
case "Routing": current.routing = value; break;
|
||||
default: break;
|
||||
case 'Identity':
|
||||
current.identity = value;
|
||||
break;
|
||||
case 'Workspace':
|
||||
current.workspace = value;
|
||||
break;
|
||||
case 'Agent dir':
|
||||
current.agentDir = value;
|
||||
break;
|
||||
case 'Model':
|
||||
current.model = value;
|
||||
break;
|
||||
case 'Routing rules': {
|
||||
const n = Number(value);
|
||||
current.routingRules = Number.isFinite(n) ? n : undefined;
|
||||
break;
|
||||
}
|
||||
case 'Routing':
|
||||
current.routing = value;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
push();
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { hostname } from 'os';
|
||||
import { getPluginConfig } from '../core/config.js';
|
||||
import { startManagedMonitor } from '../core/managed-monitor.js';
|
||||
import { getPluginConfig } from '../core/config';
|
||||
import { startManagedMonitor } from '../core/managed-monitor';
|
||||
|
||||
export function registerGatewayStartHook(api: any, deps: {
|
||||
logger: any;
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { stopManagedMonitor } from '../core/managed-monitor.js';
|
||||
import { stopManagedMonitor } from '../core/managed-monitor';
|
||||
|
||||
export function registerGatewayStopHook(api: any, deps: {
|
||||
logger: any;
|
||||
|
||||
584
plugin/index.ts
584
plugin/index.ts
@@ -11,38 +11,18 @@
|
||||
* served directly by the plugin when Monitor queries via the
|
||||
* local monitor_port communication path.
|
||||
*/
|
||||
import { hostname, freemem, totalmem, uptime, loadavg, platform } from 'node:os';
|
||||
import { definePluginEntry } from 'openclaw/plugin-sdk/plugin-entry';
|
||||
import { MultiAgentScheduleCache } from './calendar/schedule-cache.js';
|
||||
import { MultiAgentSchedulerHandle } from './calendar/multi-agent-handle.js';
|
||||
import { getPluginConfig } from './core/config.js';
|
||||
import { MonitorBridgeClient, type OpenClawMeta } from './core/monitor-bridge.js';
|
||||
import type { OpenClawAgentInfo } from './core/openclaw-agents.js';
|
||||
import { registerGatewayStartHook } from './hooks/gateway-start.js';
|
||||
import { registerGatewayStopHook } from './hooks/gateway-stop.js';
|
||||
import { hostname, freemem, totalmem, uptime, loadavg, platform } from 'os';
|
||||
import { getPluginConfig } from './core/config';
|
||||
import { MonitorBridgeClient, type OpenClawMeta } from './core/monitor-bridge';
|
||||
import { listOpenClawAgents } from './core/openclaw-agents';
|
||||
import { registerGatewayStartHook } from './hooks/gateway-start';
|
||||
import { registerGatewayStopHook } from './hooks/gateway-stop';
|
||||
import {
|
||||
createCalendarBridgeClient,
|
||||
createCalendarScheduler,
|
||||
CalendarScheduler,
|
||||
} from './calendar/index.js';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Module-scope calendar scheduler singleton.
|
||||
//
|
||||
// `register()` is called multiple times per gateway boot — once per agent
|
||||
// (we see 5 `HarborForge plugin registered` lines for 5 agents on dind-t2).
|
||||
// `gateway_start` only fires once, so before this lift the
|
||||
// `startCalendarScheduler()` setup ran inside ONE closure while four other
|
||||
// closures kept their own `calendarScheduler = null`. Whichever of the five
|
||||
// tool registrations the gateway picked at call time was effectively a coin
|
||||
// flip, and four times out of five `harborforge_calendar_status` returned
|
||||
// `Calendar scheduler not running` even though the scheduler was active.
|
||||
//
|
||||
// Keeping the singleton at module scope removes the per-`register()` shadow:
|
||||
// the scheduler is started once, every closure reads the same binding, and
|
||||
// `startCalendarScheduler()` is idempotent so duplicate `gateway_start`
|
||||
// firings are harmless.
|
||||
// ---------------------------------------------------------------------------
|
||||
let calendarScheduler: MultiAgentSchedulerHandle | CalendarScheduler | null = null;
|
||||
AgentWakeContext,
|
||||
} from './calendar';
|
||||
|
||||
interface PluginAPI {
|
||||
logger: {
|
||||
@@ -52,12 +32,6 @@ interface PluginAPI {
|
||||
warn: (...args: any[]) => void;
|
||||
};
|
||||
version?: string;
|
||||
runtime?: {
|
||||
version?: string;
|
||||
config?: {
|
||||
loadConfig?: () => any;
|
||||
};
|
||||
};
|
||||
config?: Record<string, unknown>;
|
||||
pluginConfig?: Record<string, unknown>;
|
||||
on: (event: string, handler: () => void) => void;
|
||||
@@ -73,31 +47,10 @@ interface PluginAPI {
|
||||
getAgentStatus?: () => Promise<{ status: string } | null>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Coerce a tool execute() return value into the MCP `{ content: [...] }`
|
||||
* shape that the openclaw Codex tool dispatcher requires.
|
||||
*
|
||||
* Background: openclaw's `convertToolContents()` does `result.content.reduce(...)`
|
||||
* to compute total text length before flattening. Every HF tool here returned a
|
||||
* bare object (`{ running, processing, currentSlot, ... }`) which has no
|
||||
* `.content` field, so `undefined.reduce` threw and every call to
|
||||
* `harborforge_*` from a Codex-harness agent surfaced as the cryptic
|
||||
* `Cannot read properties of undefined (reading 'reduce')`. The fix is to
|
||||
* wrap every tool's execute return; doing it at the `registerTool` boundary
|
||||
* keeps each tool body unchanged.
|
||||
*/
|
||||
function ensureMcpContentShape(result: unknown): { content: Array<{ type: 'text'; text: string }> } {
|
||||
if (
|
||||
result && typeof result === 'object' &&
|
||||
Array.isArray((result as { content?: unknown }).content)
|
||||
) {
|
||||
return result as { content: Array<{ type: 'text'; text: string }> };
|
||||
}
|
||||
const text = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
|
||||
return { content: [{ type: 'text', text }] };
|
||||
}
|
||||
|
||||
function register(api: PluginAPI): void {
|
||||
export default {
|
||||
id: 'harbor-forge',
|
||||
name: 'HarborForge',
|
||||
register(api: PluginAPI) {
|
||||
const logger = api.logger || {
|
||||
info: (...args: any[]) => console.log('[HarborForge]', ...args),
|
||||
error: (...args: any[]) => console.error('[HarborForge]', ...args),
|
||||
@@ -105,33 +58,10 @@ function register(api: PluginAPI): void {
|
||||
warn: (...args: any[]) => console.warn('[HarborForge]', ...args),
|
||||
};
|
||||
|
||||
// Wrap api.registerTool so every tool's execute() return is coerced into
|
||||
// the MCP `{ content: [...] }` shape openclaw expects. See
|
||||
// `ensureMcpContentShape` above.
|
||||
const _origRegisterTool = api.registerTool.bind(api);
|
||||
api.registerTool = (factory: (ctx: any) => any) => {
|
||||
_origRegisterTool((ctx: any) => {
|
||||
const def = factory(ctx);
|
||||
if (!def || typeof def.execute !== 'function') return def;
|
||||
const origExecute = def.execute;
|
||||
return {
|
||||
...def,
|
||||
execute: async (...args: any[]) => ensureMcpContentShape(await origExecute(...args)),
|
||||
};
|
||||
});
|
||||
};
|
||||
|
||||
function resolveConfig() {
|
||||
return getPluginConfig(api);
|
||||
}
|
||||
|
||||
/** Resolve agent ID from env, config, or fallback. */
|
||||
function resolveAgentId(): string {
|
||||
if (process.env.AGENT_ID) return process.env.AGENT_ID;
|
||||
const cfg = api.runtime?.config?.loadConfig?.();
|
||||
return cfg?.agents?.list?.[0]?.id ?? cfg?.agents?.defaults?.id ?? 'unknown';
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the monitor bridge client if monitor_port is configured.
|
||||
*/
|
||||
@@ -166,8 +96,8 @@ function register(api: PluginAPI): void {
|
||||
avg15: load[2],
|
||||
},
|
||||
openclaw: {
|
||||
version: api.runtime?.version || api.version || 'unknown',
|
||||
pluginVersion: '0.3.4', // Bumped for PLG-CAL-004
|
||||
version: api.version || 'unknown',
|
||||
pluginVersion: '0.3.1', // Bumped for PLG-CAL-004
|
||||
},
|
||||
timestamp: new Date().toISOString(),
|
||||
};
|
||||
@@ -176,9 +106,8 @@ function register(api: PluginAPI): void {
|
||||
// Periodic metadata push interval handle
|
||||
let metaPushInterval: ReturnType<typeof setInterval> | null = null;
|
||||
|
||||
// (calendarScheduler is module-scope — see top of file for the why.
|
||||
// Tools and lifecycle hooks all reference the same binding so the
|
||||
// multi-register/single-start mismatch can't shadow them again.)
|
||||
// Calendar scheduler instance
|
||||
let calendarScheduler: CalendarScheduler | null = null;
|
||||
|
||||
/**
|
||||
* Push OpenClaw metadata to the Monitor bridge.
|
||||
@@ -189,21 +118,10 @@ function register(api: PluginAPI): void {
|
||||
const bridgeClient = getBridgeClient();
|
||||
if (!bridgeClient) return;
|
||||
|
||||
let agentNames: string[] = [];
|
||||
try {
|
||||
const cfg = api.runtime?.config?.loadConfig?.();
|
||||
const agentsList = cfg?.agents?.list;
|
||||
if (Array.isArray(agentsList)) {
|
||||
agentNames = agentsList
|
||||
.map((a: any) => typeof a === 'string' ? a : a?.name)
|
||||
.filter(Boolean);
|
||||
}
|
||||
} catch { /* non-fatal */ }
|
||||
|
||||
const meta: OpenClawMeta = {
|
||||
version: api.runtime?.version || api.version || 'unknown',
|
||||
plugin_version: '0.3.4',
|
||||
agents: agentNames.map(name => ({ name })),
|
||||
version: api.version || 'unknown',
|
||||
plugin_version: '0.3.1',
|
||||
agents: await listOpenClawAgents(logger),
|
||||
};
|
||||
|
||||
const ok = await bridgeClient.pushOpenClawMeta(meta);
|
||||
@@ -233,7 +151,7 @@ function register(api: PluginAPI): void {
|
||||
|
||||
// Fallback: query backend for agent status
|
||||
const live = resolveConfig();
|
||||
const agentId = resolveAgentId();
|
||||
const agentId = process.env.AGENT_ID || 'unknown';
|
||||
try {
|
||||
const response = await fetch(`${live.backendUrl}/calendar/agent/status?agent_id=${agentId}`, {
|
||||
headers: {
|
||||
@@ -253,310 +171,117 @@ function register(api: PluginAPI): void {
|
||||
}
|
||||
|
||||
/**
|
||||
* Wake agent via dispatchInboundMessage — same mechanism used by Discord plugin.
|
||||
* Direct in-process call, no WebSocket or CLI needed.
|
||||
* Wake agent via Discord channel creation + message.
|
||||
* This is the callback invoked by CalendarScheduler when a slot is ready.
|
||||
*
|
||||
* Priority:
|
||||
* 1. Discord wakeup (create private channel + send message)
|
||||
* 2. OpenClaw spawn API (fallback if Discord not configured)
|
||||
*/
|
||||
async function wakeAgent(
|
||||
agentId: string,
|
||||
dueSlots?: Array<{
|
||||
id?: number | null;
|
||||
virtual_id?: string | null;
|
||||
event_data?: any;
|
||||
scheduled_at?: string;
|
||||
priority?: number;
|
||||
slot_type?: string;
|
||||
[k: string]: unknown;
|
||||
}>
|
||||
): Promise<boolean> {
|
||||
logger.info(`Waking agent ${agentId}: has due slots`);
|
||||
|
||||
const sessionKey = `agent:${agentId}:hf-wakeup`;
|
||||
async function wakeAgent(context: AgentWakeContext): Promise<boolean> {
|
||||
logger.info(`Waking agent for slot: ${context.taskDescription}`);
|
||||
const live = resolveConfig();
|
||||
const agentId = process.env.AGENT_ID || 'unknown';
|
||||
|
||||
try {
|
||||
const sdkPath = 'openclaw/plugin-sdk/reply-runtime';
|
||||
const { dispatchInboundMessageWithDispatcher } = await import(
|
||||
/* webpackIgnore: true */ sdkPath
|
||||
);
|
||||
// Method 1: Discord wakeup (preferred)
|
||||
const discordBotToken = (live as any).discordBotToken as string | undefined;
|
||||
const discordGuildId = (live as any).discordGuildId as string | undefined;
|
||||
|
||||
// api.config first (current public API). Fall back to deprecated
|
||||
// runtime.config.loadConfig() for older host versions. Both should
|
||||
// contain agents.list / channels for dispatch routing.
|
||||
const cfg = (api as any).config ?? api.runtime?.config?.loadConfig?.();
|
||||
if (!cfg) {
|
||||
logger.error('Cannot load OpenClaw config for dispatch');
|
||||
return false;
|
||||
if (discordBotToken && discordGuildId) {
|
||||
const { wakeAgentViaDiscord } = await import('./calendar/discord-wakeup.js');
|
||||
const success = await wakeAgentViaDiscord({
|
||||
botToken: discordBotToken,
|
||||
guildId: discordGuildId,
|
||||
agentId,
|
||||
message: context.prompt,
|
||||
logger,
|
||||
});
|
||||
if (success) return true;
|
||||
logger.warn('Discord wakeup failed, trying spawn fallback');
|
||||
}
|
||||
|
||||
// Inline the highest-priority due slot's context so the agent does
|
||||
// not need a second round-trip to harborforge_calendar_status. The
|
||||
// agent can read event_data.task_code / task_title etc. directly.
|
||||
let slotBlock = '';
|
||||
const top = dueSlots && dueSlots.length ? dueSlots[0] : undefined;
|
||||
if (top) {
|
||||
slotBlock = `\n\nMatching slot:\n\`\`\`json\n${JSON.stringify(
|
||||
{
|
||||
slot_id: top.id ?? null,
|
||||
virtual_id: top.virtual_id ?? null,
|
||||
scheduled_at: top.scheduled_at ?? null,
|
||||
priority: top.priority ?? null,
|
||||
slot_type: top.slot_type ?? null,
|
||||
event_data: top.event_data ?? null,
|
||||
},
|
||||
null,
|
||||
2
|
||||
)}\n\`\`\``;
|
||||
// Method 2: OpenClaw spawn API (fallback)
|
||||
if (api.spawn) {
|
||||
const result = await api.spawn({
|
||||
task: context.prompt,
|
||||
timeoutSeconds: context.slot.estimated_duration * 60,
|
||||
});
|
||||
|
||||
if (result?.sessionId) {
|
||||
logger.info(`Agent spawned for calendar slot: session=${result.sessionId}`);
|
||||
trackSessionCompletion(result.sessionId, context);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// The wakeup dispatcher's `deliver` callback below only logs the
|
||||
// reply text — it does NOT inspect any ack token. The earlier
|
||||
// `WAKEUP_OK` first-line-ack convention was prompt-only theatre;
|
||||
// nothing in this plugin or in openclaw acted on it. The only
|
||||
// thing that ends a wake cycle is the slot transitioning out of
|
||||
// `not_started`, which happens when the agent calls
|
||||
// `harborforge_calendar_complete` or `harborforge_calendar_abort`.
|
||||
// Tell the agent that plainly instead of asking for a fake ack.
|
||||
const wakeupMessage =
|
||||
`You have due slots. Drive the \`hf-wakeup\` workflow of skill ` +
|
||||
`\`hf-hangman-lab\` to completion in this session — read slot ` +
|
||||
`context, call the harborforge_calendar_* tools, route to the ` +
|
||||
`right sub-workflow, and finish with harborforge_calendar_complete ` +
|
||||
`or harborforge_calendar_abort. The scheduler keeps re-waking you ` +
|
||||
`every 30s until the slot transitions out of \`not_started\`, so ` +
|
||||
`partial work or silence just produces another wake.${slotBlock}`;
|
||||
logger.warn('No wakeup method available (configure discordBotToken + discordGuildId)');
|
||||
return false;
|
||||
|
||||
const result = await dispatchInboundMessageWithDispatcher({
|
||||
ctx: {
|
||||
Body: wakeupMessage,
|
||||
SessionKey: sessionKey,
|
||||
From: 'harborforge-calendar',
|
||||
Provider: 'harborforge',
|
||||
},
|
||||
cfg,
|
||||
dispatcherOptions: {
|
||||
deliver: async (payload: any) => {
|
||||
const text = (payload.text || '').trim();
|
||||
logger.info(`Agent ${agentId} wakeup reply: ${text.slice(0, 100)}`);
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
logger.info(`Agent ${agentId} dispatched: ${result?.status || 'ok'}`);
|
||||
return true;
|
||||
|
||||
} catch (err: any) {
|
||||
const msg = err?.message || err?.code || String(err);
|
||||
const stack = err?.stack?.split('\n').slice(0, 3).join(' | ') || '';
|
||||
logger.error(`Failed to dispatch agent for slot: ${msg} ${stack}`);
|
||||
} catch (err) {
|
||||
logger.error('Failed to wake agent:', err);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// (trackSessionCompletion removed — legacy single-agent poll loop that
|
||||
// called calendarScheduler.completeCurrentSlot. The multi-agent path
|
||||
// closes slots via the harborforge_calendar_complete tool, driven by
|
||||
// the agent itself, not by a timer.)
|
||||
/**
|
||||
* Track session completion and update slot status accordingly.
|
||||
*/
|
||||
function trackSessionCompletion(sessionId: string, context: AgentWakeContext): void {
|
||||
// Poll for session completion (simplified approach)
|
||||
// In production, this would use webhooks or event streaming
|
||||
const pollInterval = 30000; // 30 seconds
|
||||
const maxDuration = context.slot.estimated_duration * 60 * 1000; // Convert to ms
|
||||
const startTime = Date.now();
|
||||
|
||||
const poll = async () => {
|
||||
if (!calendarScheduler) return;
|
||||
|
||||
const elapsed = Date.now() - startTime;
|
||||
|
||||
// Check if session is complete (would use actual API in production)
|
||||
// For now, estimate completion based on duration
|
||||
if (elapsed >= maxDuration) {
|
||||
// Assume completion
|
||||
const actualMinutes = Math.round(elapsed / 60000);
|
||||
await calendarScheduler.completeCurrentSlot(actualMinutes);
|
||||
return;
|
||||
}
|
||||
|
||||
// Continue polling
|
||||
setTimeout(poll, pollInterval);
|
||||
};
|
||||
|
||||
// Start polling
|
||||
setTimeout(poll, pollInterval);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize and start the calendar scheduler.
|
||||
*
|
||||
* Idempotent — `gateway_start` may fire once per `register()` invocation
|
||||
* (the host calls `register` per agent), and we only want one set of
|
||||
* sync/check intervals across the whole process.
|
||||
*/
|
||||
function startCalendarScheduler(): void {
|
||||
if (calendarScheduler) {
|
||||
logger.info('Calendar scheduler already started, skipping duplicate gateway_start');
|
||||
return;
|
||||
}
|
||||
const live = resolveConfig();
|
||||
const agentId = process.env.AGENT_ID || 'unknown';
|
||||
|
||||
// Create bridge client (claw-instance level, not per-agent)
|
||||
// Create calendar bridge client
|
||||
const calendarBridge = createCalendarBridgeClient(
|
||||
api,
|
||||
live.backendUrl || 'https://monitor.hangman-lab.top',
|
||||
'unused' // agentId no longer needed at bridge level
|
||||
agentId
|
||||
);
|
||||
|
||||
// Multi-agent sync + check loop
|
||||
const scheduleCache = new MultiAgentScheduleCache();
|
||||
|
||||
const SYNC_INTERVAL_MS = 300_000; // 5 min
|
||||
const CHECK_INTERVAL_MS = 30_000; // 30 sec
|
||||
|
||||
// Sync: pull all agent schedules from backend
|
||||
async function runSync() {
|
||||
try {
|
||||
const result = await calendarBridge.syncSchedules();
|
||||
if (result) {
|
||||
scheduleCache.sync(result.date, result.schedules);
|
||||
const status = scheduleCache.getStatus();
|
||||
logger.info(`Schedule synced: ${status.agentCount} agents, ${status.totalSlots} slots`);
|
||||
}
|
||||
} catch (err) {
|
||||
logger.warn(`Schedule sync failed: ${String(err)}`);
|
||||
}
|
||||
}
|
||||
|
||||
// Cross-plugin exposure: agent status lookup for other plugins
|
||||
// (currently Fabric.OpenclawPlugin uses this to skip delivering
|
||||
// `announce` channel messages to busy agents — see DIALECTIC-V2
|
||||
// design doc, Phase 1). Backed by calendarBridge.getAgentStatus
|
||||
// with a small TTL cache to avoid hammering the HF backend.
|
||||
type HfStatus = 'idle' | 'on_call' | 'busy' | 'exhausted' | 'offline';
|
||||
const HF_STATUS_CACHE_TTL_MS = 30_000;
|
||||
const hfStatusCache = new Map<string, { status: HfStatus; at: number }>();
|
||||
const _G = globalThis as Record<string, unknown>;
|
||||
_G['__hfAgentStatus'] = {
|
||||
async get(agentId: string): Promise<HfStatus | undefined> {
|
||||
if (!agentId) return undefined;
|
||||
const cached = hfStatusCache.get(agentId);
|
||||
if (cached && Date.now() - cached.at < HF_STATUS_CACHE_TTL_MS) {
|
||||
return cached.status;
|
||||
}
|
||||
try {
|
||||
const status = await calendarBridge.getAgentStatus(agentId);
|
||||
if (status) {
|
||||
const typed = status as HfStatus;
|
||||
hfStatusCache.set(agentId, { status: typed, at: Date.now() });
|
||||
return typed;
|
||||
}
|
||||
} catch {
|
||||
/* fall through to cached-or-undefined */
|
||||
}
|
||||
return cached?.status;
|
||||
},
|
||||
|
||||
/**
|
||||
* Approximate "does agent have an on_call slot covering [from, to]?"
|
||||
* for cross-plugin pre-check use (currently:
|
||||
* Dialectic.OpenclawPlugin's signup HF coverage).
|
||||
*
|
||||
* v1 honest scope: we only have today's slots in scheduleCache
|
||||
* (synced from /calendar/sync which is today-only). Returns:
|
||||
* - true iff window is same-day AND some cached on_call slot
|
||||
* starts <= from AND ends >= to
|
||||
* - false iff window is same-day AND no such slot
|
||||
* - undefined for cross-day windows OR cache empty for this
|
||||
* agent (caller treats undefined as "I don't know" — see
|
||||
* Dialectic plugin's hf-precheck.ts which degrades to
|
||||
* "skipped" gracefully)
|
||||
*
|
||||
* Phase TBD: when HF backend ships a `/calendar/slots?agent&from&to`
|
||||
* endpoint, swap this to call it for arbitrary windows. Until then,
|
||||
* same-day-only coverage gates ~all debates created by analyze-intel
|
||||
* (which schedules <2h windows) without needing a backend change.
|
||||
*/
|
||||
async hasOnCallCovering(
|
||||
agentId: string,
|
||||
fromIso: string,
|
||||
toIso: string,
|
||||
): Promise<boolean | undefined> {
|
||||
if (!agentId || !fromIso || !toIso) return undefined;
|
||||
const from = new Date(fromIso);
|
||||
const to = new Date(toIso);
|
||||
if (isNaN(from.getTime()) || isNaN(to.getTime())) return undefined;
|
||||
if (!(from < to)) return undefined;
|
||||
// Cross-day → cache only has today; can't decide.
|
||||
const fromDate = from.toISOString().slice(0, 10);
|
||||
const toDate = to.toISOString().slice(0, 10);
|
||||
if (fromDate !== toDate) return undefined;
|
||||
// Cache's cachedDate must match our window's date.
|
||||
const cacheStatus = scheduleCache.getStatus();
|
||||
if (cacheStatus.cachedDate !== fromDate) return undefined;
|
||||
const slots = scheduleCache.getAgentSlots(agentId);
|
||||
if (slots.length === 0) return undefined; // cache empty for this agent — can't decide
|
||||
for (const s of slots) {
|
||||
if (s.slot_type !== 'on_call') continue;
|
||||
// status: ignore aborted/cancelled, accept not_started / ongoing / finished
|
||||
if (s.status === 'aborted' || s.status === 'cancelled') continue;
|
||||
const startStr = s.scheduled_at;
|
||||
if (typeof startStr !== 'string') continue;
|
||||
// scheduled_at can be HH:MM:SS (cache-relative date) or full ISO
|
||||
const start =
|
||||
/^\d{2}:\d{2}(:\d{2})?$/.test(startStr)
|
||||
? new Date(`${fromDate}T${startStr}Z`)
|
||||
: new Date(startStr);
|
||||
if (isNaN(start.getTime())) continue;
|
||||
const dur = typeof s.estimated_duration === 'number' ? s.estimated_duration : 0;
|
||||
const end = new Date(start.getTime() + dur * 60_000);
|
||||
if (start <= from && end >= to) return true;
|
||||
}
|
||||
return false;
|
||||
},
|
||||
};
|
||||
|
||||
// Track wakes already dispatched for a slot in the current sync
|
||||
// window — the simplified inline scheduler does not PATCH slot
|
||||
// status server-side, so without dedupe the check loop re-wakes
|
||||
// the same slot every 30s. Set is cleared by runSync (fresh wake
|
||||
// budget per sync).
|
||||
const wakedSlotKeys = new Set<string>();
|
||||
|
||||
// Check: find agents with due slots and wake them
|
||||
async function runCheck() {
|
||||
const now = new Date();
|
||||
const agentsWithDue = scheduleCache.getAgentsWithDueSlots(now);
|
||||
|
||||
for (const { agentId, slots } of agentsWithDue) {
|
||||
// Filter out slots we've already woken this sync window
|
||||
const fresh = slots.filter((s) => {
|
||||
const key = `${agentId}::${s.id ?? s.virtual_id ?? s.scheduled_at}`;
|
||||
if (wakedSlotKeys.has(key)) return false;
|
||||
return true;
|
||||
});
|
||||
if (fresh.length === 0) continue;
|
||||
|
||||
// Check if agent is busy (best effort; backend may 405 the GET
|
||||
// — treat unknown as not-busy so wakeup still fires)
|
||||
let status: string | null = null;
|
||||
try {
|
||||
status = await calendarBridge.getAgentStatus(agentId);
|
||||
} catch {
|
||||
status = null;
|
||||
}
|
||||
if (status === 'busy' || status === 'offline' || status === 'exhausted') {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Wake the agent with the slot context inlined
|
||||
const ok = await wakeAgent(agentId, fresh);
|
||||
if (ok) {
|
||||
// Top slot is the one inlined in the wakeup message; record it as
|
||||
// the agent's "current" so harborforge_calendar_complete/abort/…
|
||||
// can resolve a slot without an explicit param.
|
||||
const top = fresh[0];
|
||||
if (top && calendarScheduler instanceof MultiAgentSchedulerHandle) {
|
||||
calendarScheduler.recordWoken(agentId, top);
|
||||
}
|
||||
for (const s of fresh) {
|
||||
const key = `${agentId}::${s.id ?? s.virtual_id ?? s.scheduled_at}`;
|
||||
wakedSlotKeys.add(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Initial sync (also resets the wake-dedupe window)
|
||||
const runSyncReset = async () => {
|
||||
wakedSlotKeys.clear();
|
||||
await runSync();
|
||||
};
|
||||
runSyncReset();
|
||||
|
||||
// Start intervals
|
||||
const syncHandle = setInterval(runSyncReset, SYNC_INTERVAL_MS);
|
||||
const checkHandle = setInterval(runCheck, CHECK_INTERVAL_MS);
|
||||
|
||||
// Install the multi-agent handle so calendar tools resolve per-caller.
|
||||
calendarScheduler = new MultiAgentSchedulerHandle({
|
||||
// Create and start scheduler
|
||||
calendarScheduler = createCalendarScheduler({
|
||||
bridge: calendarBridge,
|
||||
cache: scheduleCache,
|
||||
syncHandle,
|
||||
checkHandle,
|
||||
getAgentStatus,
|
||||
wakeAgent,
|
||||
logger,
|
||||
heartbeatIntervalMs: 60000, // 1 minute
|
||||
debug: live.logLevel === 'debug',
|
||||
});
|
||||
|
||||
logger.info('Calendar scheduler started (multi-agent sync mode)');
|
||||
calendarScheduler.start();
|
||||
logger.info('Calendar scheduler started');
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -591,7 +316,7 @@ function register(api: PluginAPI): void {
|
||||
});
|
||||
|
||||
// Tool: plugin status
|
||||
api.registerTool((ctx) => ({
|
||||
api.registerTool(() => ({
|
||||
name: 'harborforge_status',
|
||||
description: 'Get HarborForge plugin status and current telemetry snapshot',
|
||||
parameters: {
|
||||
@@ -610,27 +335,13 @@ function register(api: PluginAPI): void {
|
||||
: { connected: false, error: 'Monitor bridge unreachable' };
|
||||
}
|
||||
|
||||
// Get calendar scheduler status. In multi-agent mode `currentSlot`
|
||||
// depends on the caller, so look it up via ctx.agentId.
|
||||
const callerAgentId = ctx?.agentId ?? resolveAgentId();
|
||||
const calendarStatus = calendarScheduler
|
||||
? calendarScheduler instanceof MultiAgentSchedulerHandle
|
||||
? {
|
||||
running: calendarScheduler.isRunning(),
|
||||
processing: calendarScheduler.isProcessing(),
|
||||
mode: 'multi-agent',
|
||||
callerAgentId,
|
||||
currentSlot: calendarScheduler.resolveCurrentSlot(callerAgentId),
|
||||
isRestartPending: calendarScheduler.isRestartPending(),
|
||||
}
|
||||
: {
|
||||
running: calendarScheduler.isRunning(),
|
||||
processing: calendarScheduler.isProcessing(),
|
||||
mode: 'single-agent',
|
||||
currentSlot: calendarScheduler.getCurrentSlot(),
|
||||
isRestartPending: calendarScheduler.isRestartPending(),
|
||||
}
|
||||
: null;
|
||||
// Get calendar scheduler status
|
||||
const calendarStatus = calendarScheduler ? {
|
||||
running: calendarScheduler.isRunning(),
|
||||
processing: calendarScheduler.isProcessing(),
|
||||
currentSlot: calendarScheduler.getCurrentSlot(),
|
||||
isRestartPending: calendarScheduler.isRestartPending(),
|
||||
} : null;
|
||||
|
||||
return {
|
||||
enabled: live.enabled !== false,
|
||||
@@ -689,7 +400,7 @@ function register(api: PluginAPI): void {
|
||||
}));
|
||||
|
||||
// Tool: calendar slot management
|
||||
api.registerTool((ctx) => ({
|
||||
api.registerTool(() => ({
|
||||
name: 'harborforge_calendar_status',
|
||||
description: 'Get current calendar scheduler status and pending slots',
|
||||
parameters: {
|
||||
@@ -700,24 +411,10 @@ function register(api: PluginAPI): void {
|
||||
if (!calendarScheduler) {
|
||||
return { error: 'Calendar scheduler not running' };
|
||||
}
|
||||
const callerAgentId = ctx?.agentId ?? resolveAgentId();
|
||||
if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
|
||||
return {
|
||||
running: calendarScheduler.isRunning(),
|
||||
processing: calendarScheduler.isProcessing(),
|
||||
mode: 'multi-agent',
|
||||
callerAgentId,
|
||||
currentSlot: calendarScheduler.resolveCurrentSlot(callerAgentId),
|
||||
agentSlots: calendarScheduler.cachedSlotsFor(callerAgentId),
|
||||
state: calendarScheduler.getState(),
|
||||
isRestartPending: calendarScheduler.isRestartPending(),
|
||||
stateFilePath: calendarScheduler.getStateFilePath(),
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
running: calendarScheduler.isRunning(),
|
||||
processing: calendarScheduler.isProcessing(),
|
||||
mode: 'single-agent',
|
||||
currentSlot: calendarScheduler.getCurrentSlot(),
|
||||
state: calendarScheduler.getState(),
|
||||
isRestartPending: calendarScheduler.isRestartPending(),
|
||||
@@ -727,7 +424,7 @@ function register(api: PluginAPI): void {
|
||||
}));
|
||||
|
||||
// Tool: complete current slot (for agent to report completion)
|
||||
api.registerTool((ctx) => ({
|
||||
api.registerTool(() => ({
|
||||
name: 'harborforge_calendar_complete',
|
||||
description: 'Complete the current calendar slot with actual duration',
|
||||
parameters: {
|
||||
@@ -744,20 +441,14 @@ function register(api: PluginAPI): void {
|
||||
if (!calendarScheduler) {
|
||||
return { error: 'Calendar scheduler not running' };
|
||||
}
|
||||
if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
|
||||
const agentId = ctx?.agentId ?? resolveAgentId();
|
||||
const res = await calendarScheduler.completeSlot(agentId, params.actualDurationMinutes);
|
||||
return res.ok
|
||||
? { success: true, message: 'Slot completed', slot: res.slot }
|
||||
: { error: res.error };
|
||||
}
|
||||
|
||||
await calendarScheduler.completeCurrentSlot(params.actualDurationMinutes);
|
||||
return { success: true, message: 'Slot completed' };
|
||||
},
|
||||
}));
|
||||
|
||||
// Tool: abort current slot (for agent to report failure)
|
||||
api.registerTool((ctx) => ({
|
||||
api.registerTool(() => ({
|
||||
name: 'harborforge_calendar_abort',
|
||||
description: 'Abort the current calendar slot',
|
||||
parameters: {
|
||||
@@ -773,20 +464,14 @@ function register(api: PluginAPI): void {
|
||||
if (!calendarScheduler) {
|
||||
return { error: 'Calendar scheduler not running' };
|
||||
}
|
||||
if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
|
||||
const agentId = ctx?.agentId ?? resolveAgentId();
|
||||
const res = await calendarScheduler.abortSlot(agentId, params.reason);
|
||||
return res.ok
|
||||
? { success: true, message: 'Slot aborted', slot: res.slot }
|
||||
: { error: res.error };
|
||||
}
|
||||
|
||||
await calendarScheduler.abortCurrentSlot(params.reason);
|
||||
return { success: true, message: 'Slot aborted' };
|
||||
},
|
||||
}));
|
||||
|
||||
// Tool: pause current slot
|
||||
api.registerTool((ctx) => ({
|
||||
api.registerTool(() => ({
|
||||
name: 'harborforge_calendar_pause',
|
||||
description: 'Pause the current calendar slot',
|
||||
parameters: {
|
||||
@@ -797,20 +482,14 @@ function register(api: PluginAPI): void {
|
||||
if (!calendarScheduler) {
|
||||
return { error: 'Calendar scheduler not running' };
|
||||
}
|
||||
if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
|
||||
const agentId = ctx?.agentId ?? resolveAgentId();
|
||||
const res = await calendarScheduler.pauseSlot(agentId);
|
||||
return res.ok
|
||||
? { success: true, message: 'Slot paused', slot: res.slot }
|
||||
: { error: res.error };
|
||||
}
|
||||
|
||||
await calendarScheduler.pauseCurrentSlot();
|
||||
return { success: true, message: 'Slot paused' };
|
||||
},
|
||||
}));
|
||||
|
||||
// Tool: resume current slot
|
||||
api.registerTool((ctx) => ({
|
||||
api.registerTool(() => ({
|
||||
name: 'harborforge_calendar_resume',
|
||||
description: 'Resume the paused calendar slot',
|
||||
parameters: {
|
||||
@@ -821,13 +500,7 @@ function register(api: PluginAPI): void {
|
||||
if (!calendarScheduler) {
|
||||
return { error: 'Calendar scheduler not running' };
|
||||
}
|
||||
if (calendarScheduler instanceof MultiAgentSchedulerHandle) {
|
||||
const agentId = ctx?.agentId ?? resolveAgentId();
|
||||
const res = await calendarScheduler.resumeSlot(agentId);
|
||||
return res.ok
|
||||
? { success: true, message: 'Slot resumed', slot: res.slot }
|
||||
: { error: res.error };
|
||||
}
|
||||
|
||||
await calendarScheduler.resumeCurrentSlot();
|
||||
return { success: true, message: 'Slot resumed' };
|
||||
},
|
||||
@@ -860,16 +533,5 @@ function register(api: PluginAPI): void {
|
||||
}));
|
||||
|
||||
logger.info('HarborForge plugin registered (id: harbor-forge)');
|
||||
}
|
||||
|
||||
// HarborForge's local PluginAPI is broader than the standard OpenClawPluginApi
|
||||
// (it surfaces optional `version`/`runtime`/`spawn` accessors that older
|
||||
// OpenClaw builds exposed). The cast at the definePluginEntry boundary
|
||||
// acknowledges that gap — the runtime api object is whatever the gateway
|
||||
// passes us, and each access is guarded with optional chaining / fallbacks.
|
||||
export default definePluginEntry({
|
||||
id: 'harbor-forge',
|
||||
name: 'HarborForge',
|
||||
description: 'HarborForge plugin for OpenClaw - project management, monitoring, and CLI integration',
|
||||
register: register as (api: any) => void,
|
||||
});
|
||||
},
|
||||
};
|
||||
|
||||
25
plugin/openclaw-sdk.d.ts
vendored
25
plugin/openclaw-sdk.d.ts
vendored
@@ -1,25 +0,0 @@
|
||||
// Ambient declarations for the focused subpaths of the openclaw plugin SDK
|
||||
// that this plugin needs at compile time.
|
||||
//
|
||||
// We intentionally do NOT take a `dependencies` (or `devDependencies`) entry
|
||||
// on the openclaw npm package itself: openclaw is provided by the host
|
||||
// gateway at runtime, and listing it as a file:/.../openclaw devDep breaks
|
||||
// the installer's `npm install --omit=dev` step because npm/arborist trips
|
||||
// over openclaw's own (deeply nested) dependency graph.
|
||||
//
|
||||
// These declarations cover only what we use here. They are deliberately
|
||||
// permissive — the runtime contract is whatever the gateway hands us, and
|
||||
// we guard each api access with optional chaining or a fallback at call site.
|
||||
|
||||
declare module 'openclaw/plugin-sdk/plugin-entry' {
|
||||
export function definePluginEntry<T extends {
|
||||
id: string;
|
||||
name: string;
|
||||
description?: string;
|
||||
register: (api: any) => void | Promise<void>;
|
||||
}>(opts: T): T;
|
||||
}
|
||||
|
||||
declare module 'openclaw/plugin-sdk/core' {
|
||||
export type OpenClawPluginApi = unknown;
|
||||
}
|
||||
@@ -1,23 +1,9 @@
|
||||
{
|
||||
"id": "harbor-forge",
|
||||
"name": "HarborForge",
|
||||
"version": "0.2.0",
|
||||
"description": "HarborForge plugin for OpenClaw - project management, monitoring, and CLI integration",
|
||||
"activation": {
|
||||
"onStartup": true
|
||||
},
|
||||
"contracts": {
|
||||
"tools": [
|
||||
"harborforge_status",
|
||||
"harborforge_telemetry",
|
||||
"harborforge_monitor_telemetry",
|
||||
"harborforge_calendar_status",
|
||||
"harborforge_calendar_complete",
|
||||
"harborforge_calendar_abort",
|
||||
"harborforge_calendar_pause",
|
||||
"harborforge_calendar_resume",
|
||||
"harborforge_restart_status"
|
||||
]
|
||||
},
|
||||
"entry": "./dist/index.js",
|
||||
"configSchema": {
|
||||
"type": "object",
|
||||
"additionalProperties": false,
|
||||
@@ -77,6 +63,14 @@
|
||||
"managedMonitor": {
|
||||
"type": "string",
|
||||
"description": "Absolute path to an installed HarborForge.Monitor binary managed by this plugin installer. If set, gateway_start/gateway_stop hooks will start/stop the monitor process automatically."
|
||||
},
|
||||
"discordBotToken": {
|
||||
"type": "string",
|
||||
"description": "Discord bot token for agent wakeup. Used to create private channels and send wakeup messages. Set to the same value as Dirigent moderator bot token."
|
||||
},
|
||||
"discordGuildId": {
|
||||
"type": "string",
|
||||
"description": "Discord guild ID where wakeup channels are created."
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
8
plugin/package-lock.json
generated
8
plugin/package-lock.json
generated
@@ -9,14 +9,14 @@
|
||||
"version": "0.2.0",
|
||||
"license": "MIT",
|
||||
"devDependencies": {
|
||||
"@types/node": "^20.19.41",
|
||||
"@types/node": "^20.0.0",
|
||||
"typescript": "^5.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@types/node": {
|
||||
"version": "20.19.41",
|
||||
"resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.41.tgz",
|
||||
"integrity": "sha512-ECymXOukMnOoVkC2bb1Vc/w/836DXncOg5m8Xj1RH7xSHZJWNYY6Zh7EH477vcnD5egKNNfy2RpNOmuChhFPgQ==",
|
||||
"version": "20.19.37",
|
||||
"resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
|
||||
"integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
|
||||
@@ -1,8 +1,7 @@
|
||||
{
|
||||
"name": "harbor-forge-plugin",
|
||||
"version": "0.3.4",
|
||||
"version": "0.2.0",
|
||||
"description": "OpenClaw plugin for HarborForge monitor bridge and CLI integration",
|
||||
"type": "module",
|
||||
"main": "dist/index.js",
|
||||
"scripts": {
|
||||
"clean": "rm -rf dist",
|
||||
@@ -10,7 +9,7 @@
|
||||
"watch": "tsc --watch"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^20.19.41",
|
||||
"@types/node": "^20.0.0",
|
||||
"typescript": "^5.0.0"
|
||||
},
|
||||
"license": "MIT"
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "ES2022",
|
||||
"module": "nodenext",
|
||||
"moduleResolution": "nodenext",
|
||||
"module": "CommonJS",
|
||||
"moduleResolution": "node",
|
||||
"esModuleInterop": true,
|
||||
"strict": true,
|
||||
"skipLibCheck": true,
|
||||
|
||||
Reference in New Issue
Block a user