opencode-heartbeat 0.0.9

package/README.md

@@ -0,0 +1,170 @@
+# @ali/opencode-heartbeat
+
+OpenCode Heartbeat Plugin - 心跳检测和定时任务插件
+
+## 版本
+
+0.1.0
+
+## 项目结构
+
+```
+src/
+├── index.ts                    # 插件入口，自动启动调度器
+├── HeartbeatManager.ts         # 心跳会话管理器（单例）
+├── HeartbeatSession.ts         # 单个心跳会话
+├── config.ts                   # 配置加载
+├── types.ts                    # 类型定义
+│
+├── commands/                   # 命令处理
+│   ├── start.ts               # 启动心跳命令
+│   ├── stop.ts                # 停止心跳命令
+│   └── status.ts              # 查看状态命令
+│
+├── utils/                      # 工具函数
+│   ├── validator.ts           # 文件路径和大小验证
+│   └── file-reader.ts         # 文件内容读取
+│
+└── __tests__/                 # 单元测试
+    ├── HeartbeatManager.test.ts
+    ├── HeartbeatSession.test.ts
+    └── validator.test.ts
+```
+
+## 核心功能
+
+### 1. 心跳管理
+
+- 定时向指定会话发送消息
+- 支持文本和文件两种内容类型
+- 自动清理过期会话（超过3天）
+
+### 2. 命令系统
+
+| 命令 | 说明 |
+|------|------|
+| `/heartbeat start <seconds> <content>` | 启动心跳（文本内容） |
+| `/heartbeat start <seconds> <file>` | 启动心跳（文件内容） |
+| `/heartbeat stop` | 停止当前会话的心跳 |
+| `/heartbeat status` | 查看当前会话心跳状态 |
+| `/heartbeat status all` | 查看所有心跳会话状态 |
+| `/heartbeat status <sessionId>` | 查看指定会话心跳状态 |
+
+### 3. 调度机制
+
+- 每秒检查待执行的心跳任务
+- 每分钟清理过期会话
+- 会话超时自动停止（默认3天）
+
+## 配置说明
+
+### 环境变量
+
+| 变量名 | 说明 | 默认值 |
+|--------|------|--------|
+| `HEARTBEAT_MIN_INTERVAL_MS` | 最小心跳间隔（毫秒） | 900000 (15分钟) |
+| `HEARTBEAT_MAX_DURATION_MS` | 最大心跳持续时间（毫秒） | 259200000 (3天) |
+| `HEARTBEAT_MAX_FILE_SIZE_BYTES` | 最大文件大小（字节） | 10240 (10KB) |
+| `HEARTBEAT_WORKSPACE_ROOT` | 工作空间根目录 | process.cwd() |
+
+### 配置查找顺序
+
+1. 环境变量
+2. 代码默认值
+
+## 使用方法
+
+### 安装
+
+```bash
+npm install
+```
+
+### 构建
+
+```bash
+npm run build
+```
+
+### 类型检查
+
+```bash
+npm run typecheck
+```
+
+### 运行测试
+
+```bash
+npm test
+npm run test:watch
+npm run test:coverage
+```
+
+## 命令示例
+
+### 启动文本心跳
+
+```
+/heartbeat start 900 "hello world"
+```
+
+启动一个每15分钟发送一次 "hello world" 的心跳。
+
+### 启动文件心跳
+
+```
+/heartbeat start 900 /workspace/notes.txt
+```
+
+启动一个每15分钟发送一次文件内容的心跳。
+
+### 查看状态
+
+```
+/heartbeat status
+```
+
+查看当前会话的心跳状态。
+
+### 查看所有心跳
+
+```
+/heartbeat status all
+```
+
+查看所有活跃的心跳会话。
+
+### 停止心跳
+
+```
+/heartbeat stop
+```
+
+停止当前会话的心跳。
+
+## 依赖项
+
+### dependencies
+
+| 包名 | 说明 |
+|------|------|
+| @opencode-ai/plugin | OpenCode插件接口 |
+| @opencode-ai/sdk | OpenCode SDK |
+| zod | 数据验证 |
+
+### devDependencies
+
+| 包名 | 说明 |
+|------|------|
+| @types/jest | Jest类型定义 |
+| @types/node | Node.js类型定义 |
+| jest | 测试框架 |
+| ts-jest | TypeScript Jest支持 |
+| typescript | TypeScript编译器 |
+| prettier | 代码格式化 |
+| husky | Git钩子 |
+| lint-staged | Git暂存文件检查 |
+
+## 仓库
+
+- Git: http://gitlab.alibaba-inc.com/gaode.search/opencode-heartbeat.git

package/dist/HeartbeatManager.js

@@ -0,0 +1,78 @@
+import { heartbeatConfig } from "./config.js";
+import { HeartbeatSession } from "./HeartbeatSession.js";
+const MAX_DURATION_MS = heartbeatConfig.maxDurationMs;
+const THREE_DAYS_MS = 3 * 24 * 60 * 60 * 1000;
+export class HeartbeatManager {
+    static instance;
+    sessions = new Map();
+    constructor() { }
+    static getInstance() {
+        if (!HeartbeatManager.instance) {
+            HeartbeatManager.instance = new HeartbeatManager();
+        }
+        return HeartbeatManager.instance;
+    }
+    start(sessionId, intervalMs, content, contentType) {
+        if (intervalMs < heartbeatConfig.minIntervalMs) {
+            throw new Error(`Interval ${intervalMs}ms is less than minimum ${heartbeatConfig.minIntervalMs}ms`);
+        }
+        if (this.sessions.has(sessionId)) {
+            throw new Error(`Session ${sessionId} already exists`);
+        }
+        const session = new HeartbeatSession(sessionId, intervalMs, content, contentType);
+        this.sessions.set(sessionId, session);
+    }
+    stop(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        session.stop();
+    }
+    getStatus(sessionId) {
+        if (sessionId) {
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                throw new Error(`Session ${sessionId} not found`);
+            }
+            return session.getStatus();
+        }
+        const sessions = [];
+        let runningCount = 0;
+        for (const session of this.sessions.values()) {
+            const status = session.getStatus();
+            sessions.push(status);
+            if (status.status === "running") {
+                runningCount++;
+            }
+        }
+        return {
+            sessions,
+            totalCount: sessions.length,
+            runningCount,
+        };
+    }
+    cleanupExpired() {
+        const now = Date.now();
+        let cleanedCount = 0;
+        for (const [sessionId, session] of this.sessions.entries()) {
+            const runningDuration = now - session.getStatus().startedAt;
+            if (runningDuration > THREE_DAYS_MS) {
+                session.stop();
+                cleanedCount++;
+            }
+        }
+        return cleanedCount;
+    }
+    getRunningSessions() {
+        const now = Date.now();
+        const runningSessions = [];
+        for (const session of this.sessions.values()) {
+            const status = session.getStatus();
+            if (status.status === "running" && now >= status.nextExecutionAt) {
+                runningSessions.push(session);
+            }
+        }
+        return runningSessions;
+    }
+}

package/dist/HeartbeatSession.js

@@ -0,0 +1,68 @@
+import { heartbeatConfig } from "./config.js";
+export class HeartbeatSession {
+    state;
+    constructor(sessionId, intervalMs, content, contentType) {
+        const now = Date.now();
+        this.state = {
+            sessionId,
+            intervalMs,
+            content,
+            contentType,
+            startedAt: now,
+            lastExecutedAt: null,
+            nextExecutionAt: now,
+            executionCount: 0,
+            status: "running",
+        };
+    }
+    getNextExecutionTime() {
+        return this.state.nextExecutionAt;
+    }
+    getStatus() {
+        const now = Date.now();
+        const runningDurationMs = now - this.state.startedAt;
+        return {
+            sessionId: this.state.sessionId,
+            intervalMs: this.state.intervalMs,
+            intervalDisplay: this.formatInterval(this.state.intervalMs),
+            contentType: this.state.contentType,
+            contentPreview: this.state.content.substring(0, 50),
+            startedAt: this.state.startedAt,
+            startedAtDisplay: this.formatTimestamp(this.state.startedAt),
+            lastExecutedAt: this.state.lastExecutedAt,
+            lastExecutedAtDisplay: this.state.lastExecutedAt
+                ? this.formatTimestamp(this.state.lastExecutedAt)
+                : null,
+            nextExecutionAt: this.state.nextExecutionAt,
+            nextExecutionAtDisplay: this.formatTimestamp(this.state.nextExecutionAt),
+            executionCount: this.state.executionCount,
+            status: this.state.status,
+            runningDurationMs,
+        };
+    }
+    isExpired() {
+        const now = Date.now();
+        const runningDuration = now - this.state.startedAt;
+        return runningDuration > heartbeatConfig.maxDurationMs;
+    }
+    markExecuted() {
+        const now = Date.now();
+        this.state.lastExecutedAt = now;
+        this.state.nextExecutionAt = now + this.state.intervalMs;
+        this.state.executionCount += 1;
+    }
+    stop() {
+        this.state.status = "stopped";
+    }
+    formatInterval(ms) {
+        const minutes = Math.floor(ms / 60000);
+        if (minutes >= 60) {
+            const hours = Math.floor(minutes / 60);
+            return `${hours}小时`;
+        }
+        return `${minutes}分钟`;
+    }
+    formatTimestamp(ts) {
+        return new Date(ts).toLocaleString("zh-CN");
+    }
+}

package/dist/__tests__/HeartbeatManager.test.js

@@ -0,0 +1,89 @@
+import { HeartbeatManager } from "../HeartbeatManager.js";
+describe("HeartbeatManager", () => {
+    let manager;
+    beforeEach(() => {
+        HeartbeatManager.instance = undefined;
+        manager = HeartbeatManager.getInstance();
+    });
+    describe("singleton", () => {
+        it("should return same instance", () => {
+            const instance1 = HeartbeatManager.getInstance();
+            const instance2 = HeartbeatManager.getInstance();
+            expect(instance1).toBe(instance2);
+        });
+    });
+    describe("start", () => {
+        it("should create a new session", () => {
+            manager.start("test-session-1", 900000, "test content", "text");
+            const status = manager.getStatus("test-session-1");
+            expect(status.sessionId).toBe("test-session-1");
+            expect(status.status).toBe("running");
+        });
+        it("should throw when interval is less than minimum", () => {
+            expect(() => {
+                manager.start("test-session", 1000, "test content", "text");
+            }).toThrow(/less than minimum/);
+        });
+        it("should throw when session already exists", () => {
+            manager.start("test-session", 900000, "test content", "text");
+            expect(() => {
+                manager.start("test-session", 900000, "test content", "text");
+            }).toThrow(/already exists/);
+        });
+        it("should accept file content type", () => {
+            manager.start("test-session", 900000, "/path/to/file.txt", "file");
+            const status = manager.getStatus("test-session");
+            expect(status.contentType).toBe("file");
+        });
+    });
+    describe("stop", () => {
+        it("should stop a running session", () => {
+            manager.start("test-session", 900000, "test content", "text");
+            manager.stop("test-session");
+            const status = manager.getStatus("test-session");
+            expect(status.status).toBe("stopped");
+        });
+        it("should throw when session not found", () => {
+            expect(() => {
+                manager.stop("non-existent");
+            }).toThrow(/not found/);
+        });
+    });
+    describe("getStatus", () => {
+        it("should return single session status", () => {
+            manager.start("test-session", 900000, "test content", "text");
+            const status = manager.getStatus("test-session");
+            expect(status).toHaveProperty("sessionId");
+            expect(status).toHaveProperty("intervalMs");
+            expect(status).toHaveProperty("status");
+            expect(status).toHaveProperty("startedAt");
+        });
+        it("should return all sessions status", () => {
+            manager.start("session-1", 900000, "content 1", "text");
+            manager.start("session-2", 1800000, "content 2", "text");
+            const status = manager.getStatus();
+            expect(status).toHaveProperty("sessions");
+            expect(status).toHaveProperty("totalCount");
+            expect(status).toHaveProperty("runningCount");
+            expect(status.totalCount).toBe(2);
+            expect(status.runningCount).toBe(2);
+        });
+        it("should throw when session not found", () => {
+            expect(() => {
+                manager.getStatus("non-existent");
+            }).toThrow(/not found/);
+        });
+    });
+    describe("cleanupExpired", () => {
+        it("should return 0 when no sessions", () => {
+            const count = manager.cleanupExpired();
+            expect(count).toBe(0);
+        });
+    });
+    describe("getRunningSessions", () => {
+        it("should return empty array when no sessions", () => {
+            const sessions = manager.getRunningSessions();
+            expect(sessions).toHaveLength(0);
+        });
+    });
+});

package/dist/__tests__/HeartbeatSession.test.js

@@ -0,0 +1,107 @@
+import { HeartbeatSession } from "../HeartbeatSession.js";
+describe("HeartbeatSession", () => {
+    let session;
+    beforeEach(() => {
+        session = new HeartbeatSession("test-session", 900000, "test content", "text");
+    });
+    describe("constructor", () => {
+        it("should initialize with running status", () => {
+            const status = session.getStatus();
+            expect(status.status).toBe("running");
+        });
+        it("should set sessionId correctly", () => {
+            const status = session.getStatus();
+            expect(status.sessionId).toBe("test-session");
+        });
+        it("should set intervalMs correctly", () => {
+            const status = session.getStatus();
+            expect(status.intervalMs).toBe(900000);
+        });
+        it("should set content correctly", () => {
+            const status = session.getStatus();
+            expect(status.contentPreview).toBe("test content");
+        });
+        it("should set contentType correctly", () => {
+            const status = session.getStatus();
+            expect(status.contentType).toBe("text");
+        });
+        it("should initialize executionCount to 0", () => {
+            const status = session.getStatus();
+            expect(status.executionCount).toBe(0);
+        });
+    });
+    describe("getNextExecutionTime", () => {
+        it("should return next execution timestamp", () => {
+            const nextExec = session.getNextExecutionTime();
+            expect(typeof nextExec).toBe("number");
+            expect(nextExec).toBeGreaterThan(0);
+        });
+    });
+    describe("getStatus", () => {
+        it("should return status with all required fields", () => {
+            const status = session.getStatus();
+            expect(status).toHaveProperty("sessionId");
+            expect(status).toHaveProperty("intervalMs");
+            expect(status).toHaveProperty("intervalDisplay");
+            expect(status).toHaveProperty("contentType");
+            expect(status).toHaveProperty("contentPreview");
+            expect(status).toHaveProperty("startedAt");
+            expect(status).toHaveProperty("startedAtDisplay");
+            expect(status).toHaveProperty("lastExecutedAt");
+            expect(status).toHaveProperty("lastExecutedAtDisplay");
+            expect(status).toHaveProperty("nextExecutionAt");
+            expect(status).toHaveProperty("nextExecutionAtDisplay");
+            expect(status).toHaveProperty("executionCount");
+            expect(status).toHaveProperty("status");
+            expect(status).toHaveProperty("runningDurationMs");
+        });
+        it("should return null for lastExecutedAt initially", () => {
+            const status = session.getStatus();
+            expect(status.lastExecutedAt).toBeNull();
+            expect(status.lastExecutedAtDisplay).toBeNull();
+        });
+    });
+    describe("isExpired", () => {
+        it("should return false for new session", () => {
+            expect(session.isExpired()).toBe(false);
+        });
+    });
+    describe("markExecuted", () => {
+        it("should increment executionCount", () => {
+            session.markExecuted();
+            const status = session.getStatus();
+            expect(status.executionCount).toBe(1);
+        });
+        it("should update lastExecutedAt", () => {
+            session.markExecuted();
+            const status = session.getStatus();
+            expect(status.lastExecutedAt).not.toBeNull();
+        });
+        it("should update nextExecutionAt", () => {
+            const before = session.getNextExecutionTime();
+            session.markExecuted();
+            const after = session.getNextExecutionTime();
+            expect(after).toBeGreaterThan(before);
+        });
+        it("should accumulate execution count", () => {
+            session.markExecuted();
+            session.markExecuted();
+            session.markExecuted();
+            const status = session.getStatus();
+            expect(status.executionCount).toBe(3);
+        });
+    });
+    describe("stop", () => {
+        it("should change status to stopped", () => {
+            session.stop();
+            const status = session.getStatus();
+            expect(status.status).toBe("stopped");
+        });
+        it("should prevent multiple stops", () => {
+            session.stop();
+            session.stop();
+            const status = session.getStatus();
+            expect(status.status).toBe("stopped");
+        });
+    });
+});

package/dist/__tests__/validator.test.js

@@ -0,0 +1,57 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { validateFilePath, validateFileSize, } from "../utils/validator.js";
+describe("validator", () => {
+    const testWorkspaceRoot = "/tmp/test-workspace";
+    beforeAll(async () => {
+        await fs.mkdir(testWorkspaceRoot, { recursive: true });
+    });
+    afterAll(async () => {
+        await fs.rm(testWorkspaceRoot, { recursive: true, force: true });
+    });
+    describe("validateFilePath", () => {
+        it("should return true for valid file path", () => {
+            const result = validateFilePath("/tmp/test-workspace/file.txt", testWorkspaceRoot);
+            expect(result).toBe(true);
+        });
+        it("should return false for path with parent directory traversal", () => {
+            const result = validateFilePath("/tmp/test-workspace/../../../etc/passwd", testWorkspaceRoot);
+            expect(result).toBe(false);
+        });
+        it("should return false for path outside workspace", () => {
+            const result = validateFilePath("/tmp/other-workspace/file.txt", testWorkspaceRoot);
+            expect(result).toBe(false);
+        });
+        it("should return true for nested path within workspace", () => {
+            const result = validateFilePath("/tmp/test-workspace/subdir/nested/file.txt", testWorkspaceRoot);
+            expect(result).toBe(true);
+        });
+    });
+    describe("validateFileSize", () => {
+        it("should return valid for file under max size", async () => {
+            const testFile = path.join(testWorkspaceRoot, "small.txt");
+            await fs.writeFile(testFile, "small content");
+            const result = await validateFileSize(testFile, 10240);
+            expect(result.valid).toBe(true);
+            expect(result.size).toBeLessThanOrEqual(10240);
+        });
+        it("should return invalid for file exceeding max size", async () => {
+            const testFile = path.join(testWorkspaceRoot, "large.txt");
+            const largeContent = "x".repeat(20000);
+            await fs.writeFile(testFile, largeContent);
+            const result = await validateFileSize(testFile, 10240);
+            expect(result.valid).toBe(false);
+            expect(result.error).toContain("exceeds maximum");
+        });
+        it("should return invalid for non-existent file", async () => {
+            const result = await validateFileSize("/tmp/test-workspace/non-existent.txt", 10240);
+            expect(result.valid).toBe(false);
+            expect(result.error).toContain("Cannot access file");
+        });
+        it("should return invalid for directory", async () => {
+            const result = await validateFileSize(testWorkspaceRoot, 10240);
+            expect(result.valid).toBe(false);
+            expect(result.error).toBe("Path is not a file");
+        });
+    });
+});

package/dist/commands/start.js

@@ -0,0 +1,107 @@
+import { HeartbeatManager } from "../HeartbeatManager.js";
+import { validateFilePath, validateFileSize } from "../utils/validator.js";
+import { readFileContent } from "../utils/file-reader.js";
+import { heartbeatConfig } from "../config.js";
+const MIN_INTERVAL_SECONDS = heartbeatConfig.minIntervalMs / 1000;
+/**
+ * Parse heartbeat start command arguments
+ * Format: "<seconds> <content>" or "<seconds> \"<text>\""
+ */
+function parseStartArgs(args) {
+    if (args.length < 2) {
+        return null;
+    }
+    const intervalSeconds = parseInt(args[0], 10);
+    if (isNaN(intervalSeconds) || intervalSeconds <= 0) {
+        return null;
+    }
+    // Join remaining args as content (supports quoted strings)
+    const content = args.slice(1).join(" ");
+    return {
+        intervalSeconds,
+        content,
+        isFile: !content.startsWith('"'),
+    };
+}
+/**
+ * Format interval in human-readable format
+ */
+function formatInterval(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ${hours % 24}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+}
+/**
+ * Handle heartbeat start command
+ */
+export async function handleStart(args, sessionId) {
+    try {
+        const parsed = parseStartArgs(args);
+        if (!parsed) {
+            return {
+                success: false,
+                message: `Usage: /heartbeat start <seconds> <content|file>
+Example: /heartbeat start 900 "hello"
+Example: /heartbeat start 900 test.txt`,
+            };
+        }
+        const { intervalSeconds, content, isFile } = parsed;
+        // Validate interval
+        if (intervalSeconds < MIN_INTERVAL_SECONDS) {
+            return {
+                success: false,
+                message: `Interval must be at least ${MIN_INTERVAL_SECONDS} seconds (${MIN_INTERVAL_SECONDS / 60} minutes)`,
+            };
+        }
+        const intervalMs = intervalSeconds * 1000;
+        let finalContent;
+        let contentType;
+        // Handle file or text content
+        if (isFile) {
+            const filePath = content;
+            // Validate file path
+            if (!validateFilePath(filePath, heartbeatConfig.workspaceRoot)) {
+                return {
+                    success: false,
+                    message: `Invalid file path: ${filePath}. Path must be within workspace`,
+                };
+            }
+            // Validate file size
+            const sizeValidation = await validateFileSize(filePath, heartbeatConfig.maxFileSizeBytes);
+            if (!sizeValidation.valid) {
+                return {
+                    success: false,
+                    message: `File validation failed: ${sizeValidation.error}`,
+                };
+            }
+            // Read file content
+            finalContent = await readFileContent(filePath);
+            contentType = "file";
+        }
+        else {
+            // Remove quotes from text content
+            finalContent = content.replace(/^"|"$/g, "");
+            contentType = "text";
+        }
+        // Start heartbeat
+        HeartbeatManager.getInstance().start(sessionId, intervalMs, finalContent, contentType);
+        return {
+            success: true,
+            message: `Heartbeat started: interval=${formatInterval(intervalMs)}, contentType=${contentType}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to start heartbeat: ${error.message}`,
+        };
+    }
+}

package/dist/commands/status.js

@@ -0,0 +1,63 @@
+import { HeartbeatManager } from "../HeartbeatManager.js";
+function formatTimestamp(timestamp) {
+    return new Date(timestamp).toISOString();
+}
+function formatStatusItem(status) {
+    return `
+  Session: ${status.sessionId}
+  Status: ${status.status}
+  Interval: ${status.intervalDisplay}
+  Content Type: ${status.contentType}
+  Content Preview: ${status.contentPreview}
+  Started: ${status.startedAtDisplay}
+  Last Executed: ${status.lastExecutedAtDisplay || "N/A"}
+  Next Execution: ${status.nextExecutionAtDisplay}
+  Execution Count: ${status.executionCount}
+`;
+}
+function formatAllStatus(status) {
+    const lines = [
+        `Total: ${status.totalCount}`,
+        `Running: ${status.runningCount}`,
+        "",
+    ];
+    for (const session of status.sessions) {
+        lines.push(formatStatusItem(session));
+        lines.push("---");
+    }
+    return lines.join("\n");
+}
+/**
+ * Handle heartbeat status command
+ * Args: [] = current session, ["all"] = all sessions, [sessionId] = specific session
+ */
+export function handleStatus(args, sessionId) {
+    try {
+        if (args.length === 0) {
+            const status = HeartbeatManager.getInstance().getStatus(sessionId);
+            return {
+                success: true,
+                message: formatStatusItem(status),
+            };
+        }
+        if (args[0] === "all") {
+            const status = HeartbeatManager.getInstance().getStatus();
+            return {
+                success: true,
+                message: formatAllStatus(status),
+            };
+        }
+        const targetSessionId = args[0];
+        const status = HeartbeatManager.getInstance().getStatus(targetSessionId);
+        return {
+            success: true,
+            message: formatStatusItem(status),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to get status: ${error.message}`,
+        };
+    }
+}

package/dist/commands/stop.js

@@ -0,0 +1,19 @@
+import { HeartbeatManager } from "../HeartbeatManager.js";
+/**
+ * Handle heartbeat stop command
+ */
+export function handleStop(_args, sessionId) {
+    try {
+        HeartbeatManager.getInstance().stop(sessionId);
+        return {
+            success: true,
+            message: "Heartbeat stopped",
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to stop heartbeat: ${error.message}`,
+        };
+    }
+}

package/dist/config.js

@@ -0,0 +1,9 @@
+export function loadConfig() {
+    return {
+        minIntervalMs: parseInt(process.env.HEARTBEAT_MIN_INTERVAL_MS || "900000", 10),
+        maxDurationMs: parseInt(process.env.HEARTBEAT_MAX_DURATION_MS || "259200000", 10),
+        maxFileSizeBytes: parseInt(process.env.HEARTBEAT_MAX_FILE_SIZE_BYTES || "10240", 10),
+        workspaceRoot: process.env.HEARTBEAT_WORKSPACE_ROOT || process.cwd(),
+    };
+}
+export const heartbeatConfig = loadConfig();

package/dist/index.js

@@ -0,0 +1,237 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { z } from "zod/v4";
+import { handleStart } from "./commands/start.js";
+import { handleStop } from "./commands/stop.js";
+import { handleStatus } from "./commands/status.js";
+import { HeartbeatManager } from "./HeartbeatManager.js";
+let schedulerInterval = null;
+let cleanupInterval = null;
+let pluginClient = null;
+function startScheduler(client) {
+    pluginClient = client;
+    schedulerInterval = setInterval(async () => {
+        try {
+            const sessions = HeartbeatManager.getInstance().getRunningSessions();
+            for (const session of sessions) {
+                const status = session.getStatus();
+                try {
+                    let content = status.contentPreview;
+                    if (status.contentType === "file") {
+                        content = status.contentPreview;
+                    }
+                    if (pluginClient && status.sessionId) {
+                        try {
+                            await pluginClient.session.promptAsync({
+                                path: { id: status.sessionId },
+                                body: {
+                                    parts: [{ type: "text", text: `[Heartbeat] ${content}` }],
+                                },
+                            });
+                        }
+                        catch (err) {
+                            console.error("[heartbeat] Failed to send message:", err);
+                        }
+                    }
+                    session.markExecuted();
+                }
+                catch (error) {
+                    console.error(`[heartbeat] Failed to send to session ${status.sessionId}:`, error);
+                }
+            }
+        }
+        catch (error) {
+            console.error("[heartbeat] Scheduler error:", error);
+        }
+    }, 1000);
+    cleanupInterval = setInterval(() => {
+        try {
+            const cleaned = HeartbeatManager.getInstance().cleanupExpired();
+            if (cleaned > 0) {
+                console.log(`[heartbeat] Cleaned up ${cleaned} expired sessions`);
+            }
+        }
+        catch (error) {
+            console.error("[heartbeat] Cleanup error:", error);
+        }
+    }, 60000);
+}
+function stopScheduler() {
+    if (schedulerInterval) {
+        clearInterval(schedulerInterval);
+        schedulerInterval = null;
+    }
+    if (cleanupInterval) {
+        clearInterval(cleanupInterval);
+        cleanupInterval = null;
+    }
+    pluginClient = null;
+}
+function isHeartbeatCommand(command) {
+    const lower = command.toLowerCase();
+    return (lower === "heartbeat" ||
+        lower.startsWith("heartbeat-") ||
+        lower === "hb" ||
+        lower.startsWith("hb-"));
+}
+function generateHeartbeatResponse(command, args) {
+    const cmd = command.toLowerCase();
+    if (cmd === "heartbeat" && !args) {
+        return `# /heartbeat Command
+
+**Description**: Heartbeat plugin - send periodic messages to sessions
+
+**Available Commands**:
+- \`/heartbeat-start\` - Start heartbeat
+- \`/heartbeat-stop\` - Stop current session's heartbeat
+- \`/heartbeat-status\` - View heartbeat status
+
+**Usage**:
+Use the \`heartbeat-control\` tool:
+
+\`\`\`
+heartbeat-control start --seconds 900 --content "hello world"
+heartbeat-control stop
+heartbeat-control status
+\`\`\`
+
+**Note**: Minimum interval is 900 seconds (15 minutes).
+`;
+    }
+    if (cmd === "heartbeat-start" || cmd === "hb-start") {
+        return `# /heartbeat-start Command
+
+**Description**: Start a heartbeat that sends periodic messages to the session
+
+**Usage**: \`heartbeat-control start --seconds <seconds> --content <content|file>\`
+
+**Examples**:
+\`\`\`
+heartbeat-control start --seconds 900 --content "hello world"
+heartbeat-control start --seconds 900 --content /workspace/notes.txt
+\`\`\`
+
+**Parameters**:
+- \`seconds\`: Interval in seconds (minimum 900)
+- \`content\`: Text content or file path
+`;
+    }
+    if (cmd === "heartbeat-stop" || cmd === "hb-stop" || cmd === "hb") {
+        return `# /heartbeat-stop Command
+
+**Description**: Stop the current session's heartbeat
+
+**Usage**: \`heartbeat-control stop\`
+`;
+    }
+    if (cmd === "heartbeat-status" || cmd === "hb-status") {
+        return `# /heartbeat-status Command
+
+**Description**: View heartbeat status
+
+**Usage**: 
+- \`heartbeat-control status\` - Current session status
+- \`heartbeat-control status --sessionId <id>\` - Specific session
+- \`heartbeat-control status --sessionId all\` - All sessions
+`;
+    }
+    return `# /heartbeat Command
+
+**Description**: Heartbeat plugin - command not found
+
+Use \`/heartbeat\` without arguments to see available commands.
+`;
+}
+export const OpenCodeHeartbeatPlugin = async ({ client, directory, }) => {
+    startScheduler(client);
+    const processedCommands = new Set();
+    return {
+        tool: {
+            "heartbeat-control": tool({
+                description: "Control heartbeat - start/stop/status for session",
+                args: {
+                    command: z
+                        .enum(["start", "stop", "status"])
+                        .describe("Command to execute"),
+                    seconds: z
+                        .number()
+                        .optional()
+                        .describe("Interval in seconds (for start)"),
+                    content: z
+                        .string()
+                        .optional()
+                        .describe("Content or file path (for start)"),
+                    sessionId: z
+                        .string()
+                        .optional()
+                        .describe("Session ID (optional, defaults to current)"),
+                },
+                async execute({ command, seconds, content, sessionId }) {
+                    const currentSessionId = sessionId || "default-session";
+                    switch (command) {
+                        case "start": {
+                            if (!seconds || !content) {
+                                return "Usage: heartbeat-control start --seconds <seconds> --content <content|file>";
+                            }
+                            const result = await handleStart([String(seconds), content], currentSessionId);
+                            return result.message;
+                        }
+                        case "stop": {
+                            const result = handleStop([], currentSessionId);
+                            return result.message;
+                        }
+                        case "status": {
+                            const result = handleStatus([], currentSessionId);
+                            return result.message;
+                        }
+                        default:
+                            return `Unknown command: ${command}`;
+                    }
+                },
+            }),
+        },
+        "chat.message": async (input, output) => {
+            console.log("[heartbeat] chat.message hook fired", {
+                sessionID: input.sessionID,
+                partsCount: output.parts.length,
+            });
+            const messageText = output.parts
+                .filter((p) => p.type === "text")
+                .map((p) => p.text.trim())
+                .join(" ");
+            console.log("[heartbeat] messageText:", messageText);
+            if (!messageText.startsWith("/")) {
+                console.log("[heartbeat] not a command (no / prefix)");
+                return;
+            }
+            const command = messageText.slice(1).split(/\s+/)[0];
+            const args = messageText.slice(1).split(/\s+/).slice(1).join(" ");
+            console.log("[heartbeat] parsed command:", command, "args:", args);
+            if (!isHeartbeatCommand(command)) {
+                console.log("[heartbeat] not a heartbeat command");
+                return;
+            }
+            const commandKey = `${input.sessionID}:${command}:${args}`;
+            if (processedCommands.has(commandKey)) {
+                console.log("[heartbeat] already processed, skipping");
+                return;
+            }
+            processedCommands.add(commandKey);
+            console.log("[heartbeat] generating response for:", command);
+            const response = generateHeartbeatResponse(command, args);
+            output.parts = [
+                {
+                    type: "text",
+                    text: response,
+                },
+            ];
+            console.log("[heartbeat] response set, parts replaced");
+        },
+    };
+};
+export default OpenCodeHeartbeatPlugin;
+async function shutdown() {
+    stopScheduler();
+    process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);

package/dist/tui.js

@@ -0,0 +1,55 @@
+async function tuiHeartbeatPlugin(api, _options, _meta) {
+    api.command.register(() => [
+        {
+            title: "Start Heartbeat",
+            value: "heartbeat-start",
+            description: "启动心跳 (间隔至少15分钟)",
+            category: "Heartbeat",
+            slash: {
+                name: "heartbeat",
+            },
+            onSelect: () => {
+                api.ui.toast({
+                    variant: "info",
+                    message: "Usage: /heartbeat start <seconds> <content>",
+                });
+                api.command.show();
+            },
+        },
+        {
+            title: "Stop Heartbeat",
+            value: "heartbeat-stop",
+            description: "停止当前session的心跳",
+            category: "Heartbeat",
+            slash: {
+                name: "heartbeat-stop",
+                aliases: ["hb-stop"],
+            },
+            onSelect: async () => {
+                api.ui.toast({
+                    variant: "info",
+                    message: "Use tool: heartbeat-control stop",
+                });
+            },
+        },
+        {
+            title: "Heartbeat Status",
+            value: "heartbeat-status",
+            description: "查看心跳状态",
+            category: "Heartbeat",
+            slash: {
+                name: "heartbeat-status",
+                aliases: ["hb-status"],
+            },
+            onSelect: async () => {
+                api.ui.toast({
+                    variant: "info",
+                    message: "Use tool: heartbeat-control status",
+                });
+            },
+        },
+    ]);
+}
+export default {
+    tui: tuiHeartbeatPlugin,
+};

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Heartbeat Plugin Type Definitions
+ */
+export {};

package/dist/utils/file-reader.js

@@ -0,0 +1,5 @@
+import * as fs from "fs/promises";
+export async function readFileContent(filePath) {
+    const content = await fs.readFile(filePath, { encoding: "utf-8" });
+    return content;
+}

package/dist/utils/validator.js

@@ -0,0 +1,40 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+export function validateFilePath(filePath, workspaceRoot) {
+    const absolutePath = path.resolve(filePath);
+    const absoluteWorkspace = path.resolve(workspaceRoot);
+    if (absolutePath.includes("..")) {
+        return false;
+    }
+    return absolutePath.startsWith(absoluteWorkspace);
+}
+export async function validateFileSize(filePath, maxSizeBytes) {
+    try {
+        const stats = await fs.stat(filePath);
+        if (!stats.isFile()) {
+            return {
+                valid: false,
+                size: 0,
+                error: "Path is not a file",
+            };
+        }
+        if (stats.size > maxSizeBytes) {
+            return {
+                valid: false,
+                size: stats.size,
+                error: `File size ${stats.size} exceeds maximum ${maxSizeBytes}`,
+            };
+        }
+        return {
+            valid: true,
+            size: stats.size,
+        };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            size: 0,
+            error: `Cannot access file: ${error.message}`,
+        };
+    }
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "version": "0.0.9",
+  "description": "OpenCode Heartbeat Plugin - 心跳检测和定时任务插件",
+  "main": "./dist/index.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./tui": {
+      "import": "./dist/tui.js",
+      "types": "./dist/tui.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://gitlab.alibaba-inc.com/gaode.search/opencode-heartbeat.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.anpm.alibaba-inc.com"
+  },
+  "keywords": [
+    "opencode-heartbeat",
+    "opencode",
+    "plugin",
+    "heartbeat",
+    "cron"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@opencode-ai/plugin": "1.1.53",
+    "@opencode-ai/sdk": "1.1.53",
+    "zod": "4.1.8"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.13.9",
+    "husky": "^8.0.3",
+    "jest": "^30.3.0",
+    "lint-staged": "^13.2.3",
+    "prettier": "^3.0.2",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.8.2"
+  },
+  "name": "opencode-heartbeat"
+}