my-opencode-toolkit 0.2.3 → 0.2.4

package/README.md

@@ -63,6 +63,7 @@ OpenCode v2 插件：系统通知、持久目标、定时任务与循环、TUI
   - 下一次触发在四年窗口内搜索，支持 `2 月 29 日`；永远不存在的日期会被拒绝
 - 每会话最多 50 个任务；重复任务 7 天后自动过期
 - durable 任务存插件存储，重启恢复并重新武装 timer；非 durable 只留内存
+- 循环只存在内存，重启后消失；需要跨重启请用 cron
 - 循环：固定间隔或动态（模型用 `schedule_wakeup` 决定下次，60–3600 秒，20 分钟兜底）
 - 固定间隔范围 60 秒 – 7 天；裸 `/loop` 使用内置维护提示词，项目根目录有非空 `loop.md` 时优先用它
 
@@ -135,6 +136,8 @@ OpenCode v2 插件：系统通知、持久目标、定时任务与循环、TUI
 - 侧栏统计是进程内数据：重启后第一次打开面板会从已存消息重建（重建瞬间完成的一步可能漏算）
 - 通知依赖系统命令：Windows 用 PowerShell toast，macOS 用 `osascript`，Linux 用 `notify-send`
 - 定时任务按 OpenCode 进程的本地时区解析；不支持秒级字段与 `L` / `W` / `?` 等扩展语法
+- 夏令时切换当天，本地时间的 cron 可能跳过或重复一次（标准 cron 语义的固有问题）
+- 同一会话不要同时开多个 OpenCode 实例执行目标/定时任务；插件存储没有跨进程锁
 - 目标进行中时 cron/loop 让路，避免和续作抢同一轮对话
 - 子代理会话不提供 goal/scheduling 工具，也不会被注入续作
 
@@ -169,7 +172,7 @@ OpenCode v2 插件：系统通知、持久目标、定时任务与循环、TUI
 
 ```bash
 pnpm install
-pnpm check        # typecheck + lint + 161 单测 + TUI 测试
+pnpm check        # typecheck + lint + 175 单测 + TUI 测试 + 发布包内容校验
 pnpm test:e2e     # 需要本机 opencode 2.x 与 bun，使用隔离的 HOME/DB/config
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-opencode-toolkit",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "OpenCode 插件：系统通知、持久目标、定时任务与 TUI 面板",
   "type": "module",
   "license": "MIT",
@@ -45,7 +45,8 @@
   "scripts": {
     "typecheck": "tsc --noEmit",
     "lint": "eslint .",
-    "check": "pnpm typecheck && pnpm lint && pnpm test && pnpm test:tui",
+    "check": "pnpm typecheck && pnpm lint && pnpm test && pnpm test:tui && pnpm check:package",
+    "check:package": "node scripts/check-package.mjs",
     "test": "vitest run",
     "test:tui": "cd tui-test && bun test",
     "test:e2e": "bun scripts/e2e-load.mjs",

package/src/goal/command.ts

@@ -70,8 +70,11 @@ export async function registerGoalCommand(
       description: DESCRIPTION,
       execute: async (input) => {
         const settings = await loadSettings(ctx.storage)
+        const parsed = parseGoalCommand(input.prompt.text)
+        // clear / show 是清理与查看，功能关闭时也允许，避免目标被永久锁在存储里。
+        const readOnly = parsed.kind === "clear" || parsed.kind === "show"
         const text =
-          settings.enabled && settings.goal.enabled
+          (settings.enabled && settings.goal.enabled) || readOnly
             ? await applyGoalCommand(controller, continuation, input.sessionID, input.prompt.text)
             : "Error: the goal feature is disabled in settings."
         // /goal 只关心文本参数；附件不回传，避免把命令附件重复塞进会话。

package/src/goal/continuation.ts

@@ -123,6 +123,8 @@ export function createGoalContinuation(args: {
 
   /** 输入：会话 ID + 错误载荷；输出：无。预期：余额不足/超长锁死，其余只记录。 */
   const handleFailure = async (sessionID: string, error: unknown): Promise<void> => {
+    // 这一轮已经失败，清掉待确认注入，下一次 idle 才能重试。
+    pending.delete(sessionID)
     if (!(await enabled())) return
 
     const state = stateOf(sessionID)
@@ -139,6 +141,8 @@ export function createGoalContinuation(args: {
 
   /** 输入：会话 ID + 打断原因；输出：无。预期：用户打断时暂停目标。 */
   const handleInterrupted = async (sessionID: string, reason: string): Promise<void> => {
+    // 任何打断都意味着这一轮结束，清掉待确认注入。
+    pending.delete(sessionID)
     if (reason !== "user") return
     if (!(await enabled())) return
     const state = stateOf(sessionID)

package/src/notification/send.ts

@@ -13,22 +13,42 @@ const NOTIFY_SEND = "notify-send"
 const TITLE_MAX = 100
 const MESSAGE_MAX = 800
 
+/** 命令探测超时；发送超时。 */
+const PROBE_TIMEOUT_MS = 3_000
+const SEND_TIMEOUT_MS = 10_000
+
 /** 发送函数。 */
 export type NotificationSender = (title: string, message: string) => Promise<void>
 
+/**
+ * 命令执行器。
+ *
+ * 输入：命令、参数、超时毫秒。
+ * 输出：命令成功退出时 resolve。
+ * 预期：默认实现走 `execFile`；测试可注入假实现，验证各平台的参数与转义。
+ */
+export type CommandRunner = (command: string, args: readonly string[], timeoutMs: number) => Promise<void>
+
+const defaultRunner: CommandRunner = (command, args, timeoutMs) =>
+  execFileAsync(command, [...args], { timeout: timeoutMs, windowsHide: true }).then(() => undefined)
+
 /** 输入：文本 + 上限；输出：截断后的文本。 */
 function truncate(text: string, max: number): string {
   return text.length > max ? `${text.slice(0, max)}...` : text
 }
 
 /**
- * 输入：命令名 + 该命令能快速成功退出的探测参数。
+ * 输入：命令名 + 该命令能快速成功退出的探测参数 + 执行器。
  * 输出：可用时返回命令名，否则 `null`。
  * 预期：结果缓存；探测超时 3 秒，不阻塞通知链路。
  *       探测参数必须按命令区分：把 PowerShell 的 `-Command` 传给 osascript/notify-send 会必然失败，
  *       导致这两个平台的命令被误判为不存在。
  */
-function createCommandFinder(commandName: string, probeArgs: readonly string[]): () => Promise<string | null> {
+function createCommandFinder(
+  commandName: string,
+  probeArgs: readonly string[],
+  runner: CommandRunner,
+): () => Promise<string | null> {
   let cached: string | null | undefined
   let pending: Promise<string | null> | undefined
 
@@ -38,10 +58,7 @@ function createCommandFinder(commandName: string, probeArgs: readonly string[]):
 
     pending = (async () => {
       try {
-        await execFileAsync(commandName, [...probeArgs], {
-          timeout: 3_000,
-          windowsHide: true,
-        })
+        await runner(commandName, probeArgs, PROBE_TIMEOUT_MS)
         cached = commandName
       } catch {
         cached = null
@@ -52,52 +69,59 @@ function createCommandFinder(commandName: string, probeArgs: readonly string[]):
   }
 }
 
-const findPowerShell = createCommandFinder(POWERSHELL, ["-NoProfile", "-Command", "exit 0"])
-const findOsascript = createCommandFinder(OSASCRIPT, ["-e", "return"])
-const findNotifySend = createCommandFinder(NOTIFY_SEND, ["--help"])
-
-/** 输入：命令 + 参数；输出：无。预期：静默执行，失败由调用方忽略。 */
-async function runQuiet(command: string, args: readonly string[]): Promise<void> {
-  await execFileAsync(command, [...args], { timeout: 10_000, windowsHide: true })
-}
-
-/** 输入：标题 + 正文；输出：无。预期：没有 powershell 时静默跳过。 */
-async function sendWindows(title: string, message: string): Promise<void> {
-  const path = await findPowerShell()
-  if (path === null) return
-  const script = buildWindowsToastScript(truncate(title, TITLE_MAX), truncate(message, MESSAGE_MAX))
-  await runQuiet(path, ["-NoProfile", "-NonInteractive", "-Command", script])
+/** 输入：执行器；输出：Windows toast 发送函数。 */
+function windowsSender(runner: CommandRunner): NotificationSender {
+  const find = createCommandFinder(POWERSHELL, ["-NoProfile", "-Command", "exit 0"], runner)
+  return async (title, message) => {
+    const path = await find()
+    if (path === null) return
+    const script = buildWindowsToastScript(truncate(title, TITLE_MAX), truncate(message, MESSAGE_MAX))
+    await runner(path, ["-NoProfile", "-NonInteractive", "-Command", script], SEND_TIMEOUT_MS)
+  }
 }
 
-/** 输入：标题 + 正文；输出：无。预期：没有 osascript 时静默跳过。 */
-async function sendMacos(title: string, message: string): Promise<void> {
-  const path = await findOsascript()
-  if (path === null) return
-  const safeTitle = escapeAppleScriptText(truncate(title, TITLE_MAX))
-  const safeMessage = escapeAppleScriptText(truncate(message, MESSAGE_MAX))
-  await runQuiet(path, ["-e", `display notification "${safeMessage}" with title "${safeTitle}"`])
+/** 输入：执行器；输出：macOS 通知发送函数。 */
+function macosSender(runner: CommandRunner): NotificationSender {
+  const find = createCommandFinder(OSASCRIPT, ["-e", "return"], runner)
+  return async (title, message) => {
+    const path = await find()
+    if (path === null) return
+    const safeTitle = escapeAppleScriptText(truncate(title, TITLE_MAX))
+    const safeMessage = escapeAppleScriptText(truncate(message, MESSAGE_MAX))
+    await runner(
+      path,
+      ["-e", `display notification "${safeMessage}" with title "${safeTitle}"`],
+      SEND_TIMEOUT_MS,
+    )
+  }
 }
 
-/** 输入：标题 + 正文；输出：无。预期：没有 notify-send 时静默跳过。 */
-async function sendLinux(title: string, message: string): Promise<void> {
-  const path = await findNotifySend()
-  if (path === null) return
-  await runQuiet(path, [truncate(title, TITLE_MAX), truncate(message, MESSAGE_MAX)])
+/** 输入：执行器；输出：Linux 通知发送函数。 */
+function linuxSender(runner: CommandRunner): NotificationSender {
+  const find = createCommandFinder(NOTIFY_SEND, ["--help"], runner)
+  return async (title, message) => {
+    const path = await find()
+    if (path === null) return
+    await runner(path, [truncate(title, TITLE_MAX), truncate(message, MESSAGE_MAX)], SEND_TIMEOUT_MS)
+  }
 }
 
 /**
- * 输入：Node 平台字符串。
+ * 输入：Node 平台字符串 + 可选执行器。
  * 输出：该平台的发送函数。
- * 预期：不支持的平台返回空实现，绝不抛错。
+ * 预期：不支持的平台返回空实现，绝不抛错；每个 sender 各自缓存命令探测结果。
  */
-export function createSender(platform: NodeJS.Platform): NotificationSender {
+export function createSender(
+  platform: NodeJS.Platform,
+  runner: CommandRunner = defaultRunner,
+): NotificationSender {
   switch (platform) {
     case "win32":
-      return sendWindows
+      return windowsSender(runner)
     case "darwin":
-      return sendMacos
+      return macosSender(runner)
     case "linux":
-      return sendLinux
+      return linuxSender(runner)
     default:
       return () => Promise.resolve()
   }

package/src/scheduling/command.ts

@@ -106,8 +106,9 @@ export async function registerSchedulingCommands(
       name: "loop",
       description: "Start or stop a recurring prompt loop in this session",
       execute: async (input) => {
-        const blocked = await unavailable(input.sessionID)
         const parsed = parseLoopCommand(input.prompt.text)
+        // stop 即使功能关闭也要能执行，否则用户没法停掉正在跑的循环。
+        const blocked = parsed.kind === "stop" ? null : await unavailable(input.sessionID)
         const text = await (async (): Promise<string> => {
           if (blocked !== null) return blocked
           if (parsed.kind === "stop") {
@@ -128,8 +129,10 @@ export async function registerSchedulingCommands(
       name: "cron",
       description: "Create, list or delete scheduled prompts for this session",
       execute: async (input) => {
-        const blocked = await unavailable(input.sessionID)
         const raw = input.prompt.text.trim()
+        // list / delete 属于清理操作，功能关闭时也允许；只有创建需要开关。
+        const readOnly = raw === "" || raw.toLowerCase() === "list" || /^delete\s+\S+$/i.test(raw)
+        const blocked = readOnly ? null : await unavailable(input.sessionID)
         const text = await (async (): Promise<string> => {
           if (blocked !== null) return blocked
 

package/src/scheduling/continuation.ts

@@ -175,6 +175,8 @@ export function createSchedulingContinuation(args: {
       if (typeof sessionID !== "string" || sessionID.length === 0) return
 
       if (event.type === "session.idle") {
+        // idle 表示上一轮已经结束；清掉 pending 让本轮可以继续注入。
+        pending.delete(sessionID)
         await handleIdle(sessionID)
         return
       }
@@ -196,6 +198,10 @@ export function createSchedulingContinuation(args: {
       if (event.type === "session.step.ended" || event.type === "session.usage.updated") {
         pending.delete(sessionID)
       }
+      // 注入后模型失败/被打断时清掉 pending，避免后续任务永远被挡住。
+      if (event.type === "session.execution.failed" || event.type === "session.execution.interrupted") {
+        pending.delete(sessionID)
+      }
     },
 
     armTimers,

package/src/scheduling/index.ts

@@ -35,7 +35,13 @@ export async function registerScheduling(
   const jobs = createSchedulingStore(store)
   await jobs.load()
 
-  const scheduler = createLoopScheduler({ ctx, roles, shouldDefer })
+  /** 输入：无；输出：总开关与 scheduling 开关是否都打开。 */
+  const isEnabled = async (): Promise<boolean> => {
+    const settings = await loadSettings(store)
+    return settings.enabled && settings.scheduling.enabled
+  }
+
+  const scheduler = createLoopScheduler({ ctx, roles, shouldDefer, enabled: isEnabled })
   const tools = await registerSchedulingTools(ctx, jobs, scheduler, roles)
   const commands = await registerSchedulingCommands(ctx, jobs, scheduler, roles)
 
@@ -44,10 +50,7 @@ export async function registerScheduling(
     store: jobs,
     roles,
     shouldDefer,
-    enabled: async () => {
-      const settings = await loadSettings(store)
-      return settings.enabled && settings.scheduling.enabled
-    },
+    enabled: isEnabled,
   })
   continuation.armTimers()
 

package/src/scheduling/loops.ts

@@ -55,8 +55,11 @@ export function createLoopScheduler(args: {
   readonly ctx: Plugin.Context
   readonly roles: SessionRoles
   readonly shouldDefer: (sessionID: string) => Promise<boolean>
+  /** 输入：无；输出：scheduling 是否启用。缺省视为启用（测试与旧调用兼容）。 */
+  readonly enabled?: () => Promise<boolean>
 }): LoopScheduler {
   const { ctx, roles, shouldDefer } = args
+  const isEnabled = args.enabled ?? ((): Promise<boolean> => Promise.resolve(true))
   const loops = new Map<string, Loop>()
   const timers = new Map<string, ReturnType<typeof setTimeout>>()
   const inFlight = new Set<string>()
@@ -90,6 +93,8 @@ export function createLoopScheduler(args: {
       stopLoop(loop.sessionID, loop.id)
       return
     }
+    // 功能关闭时循环暂停，但不销毁；重新开启后下一个 timer 继续。
+    if (!(await isEnabled().catch(() => false))) return
     if (await shouldDefer(loop.sessionID).catch(() => false)) return
     loop.fires += 1
     await inject(loop.sessionID, loop.prompt)
@@ -243,6 +248,14 @@ export function createLoopScheduler(args: {
       if (event.type === "session.step.ended" || event.type === "session.usage.updated") {
         pending.delete(sessionID)
       }
+      // 注入后模型失败/被打断/直接 idle 时清掉 pending，否则循环会被永久卡住。
+      if (
+        event.type === "session.execution.failed" ||
+        event.type === "session.execution.interrupted" ||
+        event.type === "session.idle"
+      ) {
+        pending.delete(sessionID)
+      }
       return Promise.resolve()
     },
 

package/src/shared/scan.ts

@@ -15,7 +15,8 @@ export async function forEachScannedEntry(
   for (;;) {
     const page = await store.scan({ prefix, limit, ...(after === undefined ? {} : { after }) })
     for (const entry of page.entries) await visit(entry)
-    if (page.next === undefined) return
+    // 游标不前进时立即停下，防止异常存储导致死循环。
+    if (page.next === undefined || page.next === after) return
     after = page.next
   }
 }