minimal-agent 0.8.2 → 0.10.0

package/plugins/cron-runner/src/store.js

@@ -0,0 +1,298 @@
+import { randomUUID } from 'node:crypto';
+import { constants, copyFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { cronToHuman } from './cronTime.js';
+import { intervalToHuman, nextScheduleRunMs } from './scheduleEngine.js';
+import { schedulerLockFile } from './lock.js';
+import { appendMissed as appendMissedRecord, appendRun as appendRunRecord, listMissed as listMissedRecords, markMissedRead as markMissedRecordsRead, markRunsRead as markRunRecordsRead, recentRuns as readRecentRuns } from './runs.js';
+import { normalizeTask } from './schema.js';
+function root() {
+    return process.env.MINIMAL_AGENT_CRON_RUNNER_HOME
+        ? join(process.env.MINIMAL_AGENT_CRON_RUNNER_HOME, 'cron-runner')
+        : join(homedir(), '.minimal-agent', 'plugins', 'cron-runner');
+}
+function tasksFile() {
+    return join(root(), 'tasks.json');
+}
+function runsDir() {
+    return join(root(), 'runs');
+}
+function missedFile() {
+    return join(root(), 'missed.jsonl');
+}
+let mutationQueue = Promise.resolve();
+const taskChangeListeners = new Set();
+function notifyTaskChanges() {
+    for (const listener of taskChangeListeners)
+        listener();
+}
+export function subscribeTaskChanges(listener) {
+    taskChangeListeners.add(listener);
+    return () => taskChangeListeners.delete(listener);
+}
+export function cronDataRoot() {
+    return root();
+}
+export function cronLockFile() {
+    return schedulerLockFile(root());
+}
+/** Upgrade legacy fresh/hidden-session tasks once, keeping an immutable pre-migration backup. */
+export async function migrateCronTasks() {
+    return await enqueueMutation(async () => {
+        let raw;
+        try {
+            raw = await readFile(tasksFile(), 'utf8');
+        }
+        catch {
+            return false;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return false;
+        }
+        if (!Array.isArray(parsed.tasks))
+            return false;
+        const needsMigration = parsed.tasks.some((value) => {
+            const task = value;
+            return !task.schedule || !('type' in task.schedule) || !task.runtime?.bindingStatus || task.runtime.sessionMode === 'fresh' || task.runtime.sessionId?.startsWith('cron-');
+        });
+        if (!needsMigration)
+            return false;
+        await mkdir(root(), { recursive: true });
+        try {
+            await copyFile(tasksFile(), join(root(), 'tasks.pre-session-binding.backup.json'), constants.COPYFILE_EXCL);
+        }
+        catch { /* existing backup is intentionally retained */ }
+        const migrated = parsed.tasks.map(normalizeTask).filter((task) => Boolean(task));
+        await writeTasksFile(migrated);
+        notifyTaskChanges();
+        return true;
+    });
+}
+async function readTasks(fromMs = Date.now()) {
+    try {
+        const raw = await readFile(tasksFile(), 'utf8');
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed.tasks)
+            ? parsed.tasks
+                .map(normalizeTask)
+                .filter((task) => Boolean(task))
+                // 注意：不能写成 .map(refreshNextRun)——Array.map 会把 (element, index, array)
+                // 全传进去，第二个实参 index(0,1,2...) 会顶掉 refreshNextRun 的 fromMs=Date.now()
+                // 默认值，导致 nextRunAt/expired 全按 Unix 纪元(≈0ms)计算（真机 e2e 抓到
+                // nextRunAt 恒为 1970-01-01）。必须用箭头包一层只透传 task。
+                .map((task) => refreshNextRun(task, fromMs))
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function listTasks() {
+    return await readTasks();
+}
+async function writeTasksFile(tasks) {
+    const file = tasksFile();
+    await mkdir(dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmp, JSON.stringify({ tasks: tasks.map((task) => refreshNextRun(task)) }, null, 2), 'utf8');
+    await rename(tmp, file);
+}
+function enqueueMutation(mutate) {
+    const operation = mutationQueue.then(mutate, mutate);
+    mutationQueue = operation.then(() => undefined, () => undefined);
+    return operation;
+}
+export async function writeTasks(tasks) {
+    await enqueueMutation(async () => {
+        await writeTasksFile(tasks);
+        notifyTaskChanges();
+    });
+}
+export async function upsertTask(task) {
+    return await enqueueMutation(async () => {
+        const tasks = await readTasks();
+        const idx = tasks.findIndex((t) => t.id === task.id);
+        const saved = refreshNextRun({ ...task, updatedAt: new Date().toISOString() });
+        if (idx >= 0)
+            tasks[idx] = saved;
+        else
+            tasks.push(saved);
+        await writeTasksFile(tasks);
+        notifyTaskChanges();
+        return saved;
+    });
+}
+export async function updateTask(id, updater) {
+    return await enqueueMutation(async () => {
+        const tasks = await readTasks();
+        const idx = tasks.findIndex((task) => task.id === id);
+        if (idx < 0)
+            return undefined;
+        const saved = refreshNextRun({
+            ...updater(tasks[idx]),
+            updatedAt: new Date().toISOString(),
+        });
+        tasks[idx] = saved;
+        await writeTasksFile(tasks);
+        notifyTaskChanges();
+        return saved;
+    });
+}
+export async function deleteTask(id) {
+    return await enqueueMutation(async () => {
+        const tasks = await readTasks();
+        const next = tasks.filter((t) => t.id !== id);
+        if (next.length === tasks.length)
+            return false;
+        await writeTasksFile(next);
+        notifyTaskChanges();
+        return true;
+    });
+}
+export async function getTask(idOrPrefix) {
+    const tasks = await listTasks();
+    return tasks.find((t) => t.id === idOrPrefix) ?? tasks.find((t) => t.id.startsWith(idOrPrefix));
+}
+export async function appendRun(record) {
+    await appendRunRecord(runsDir(), record);
+}
+export async function recentRuns(taskId, limit = 5) {
+    return await readRecentRuns(runsDir(), taskId, limit);
+}
+export async function markRunsRead(taskId) {
+    await markRunRecordsRead(runsDir(), taskId);
+}
+export async function appendMissed(record) {
+    await appendMissedRecord(missedFile(), record);
+}
+export async function listMissed(limit = 20) {
+    return await listMissedRecords(missedFile(), limit);
+}
+export async function markMissedRead(taskId) {
+    await markMissedRecordsRead(missedFile(), taskId);
+}
+export function createTask(input) {
+    const now = new Date().toISOString();
+    const id = `cron-${randomUUID().slice(0, 8)}`;
+    if (!input.cron && !input.intervalMs) {
+        throw new Error('createTask requires cron or intervalMs');
+    }
+    const schedule = input.intervalMs
+        ? {
+            type: 'interval',
+            intervalMs: input.intervalMs,
+            anchorAt: input.anchorAt ?? now,
+            human: intervalToHuman(input.intervalMs),
+            jitterMs: input.jitterMs ?? 0,
+        }
+        : {
+            type: 'cron',
+            cron: input.cron,
+            timezone: input.timezone,
+            human: cronToHuman(input.cron),
+            jitterMs: input.jitterMs ?? 0,
+        };
+    return refreshNextRun({
+        id,
+        name: input.name,
+        ...(input.description ? { description: input.description } : {}),
+        status: 'active',
+        kind: input.kind ?? 'recurring',
+        ...(input.permanent ? { permanent: true } : {}),
+        ...(input.expiresAt ? { expiresAt: input.expiresAt } : {}),
+        ...(input.maxRuns ? { maxRuns: input.maxRuns } : {}),
+        schedule,
+        action: input.action,
+        runtime: {
+            cwd: input.cwd,
+            environment: 'project',
+            sessionId: input.sessionId ?? 'default',
+            sessionMode: input.sessionMode ?? 'persistent',
+            bindingStatus: (!input.sessionId || !input.sessionId.startsWith('cron-')) && input.sessionMode !== 'fresh'
+                ? 'bound'
+                : 'needs_binding',
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.maxTurns ? { maxTurns: input.maxTurns } : {}),
+        },
+        stats: {
+            runCount: 0,
+            successCount: 0,
+            failureCount: 0,
+            skippedCount: 0,
+        },
+        createdAt: now,
+        updatedAt: now,
+    });
+}
+export function refreshNextRun(task, fromMs = Date.now()) {
+    const expired = task.expiresAt && !task.permanent && Date.parse(task.expiresAt) <= fromMs;
+    const next = task.status === 'active' && !expired
+        ? nextScheduleRunMs(task.schedule, fromMs)
+        : null;
+    return {
+        ...task,
+        ...(expired ? { status: 'completed' } : {}),
+        schedule: {
+            ...task.schedule,
+            human: task.schedule.type === 'cron'
+                ? cronToHuman(task.schedule.cron)
+                : intervalToHuman(task.schedule.intervalMs),
+            jitterMs: typeof task.schedule.jitterMs === 'number' ? task.schedule.jitterMs : 0,
+            ...(next ? { nextRunAt: new Date(next).toISOString() } : { nextRunAt: undefined }),
+        },
+    };
+}
+/** Update only user-editable fields while preserving scheduler cursors, stats and creation time. */
+export async function patchTask(patch) {
+    return await updateTask(patch.id, (current) => {
+        const nextSchedule = patch.schedule
+            ? patch.schedule.type === 'cron'
+                ? {
+                    ...current.schedule,
+                    type: 'cron',
+                    cron: patch.schedule.cron,
+                    timezone: patch.schedule.timezone,
+                    jitterMs: patch.schedule.jitterMs ?? 0,
+                    human: cronToHuman(patch.schedule.cron),
+                }
+                : {
+                    ...current.schedule,
+                    type: 'interval',
+                    intervalMs: patch.schedule.intervalMs,
+                    anchorAt: patch.schedule.anchorAt ?? new Date().toISOString(),
+                    jitterMs: patch.schedule.jitterMs ?? 0,
+                    human: intervalToHuman(patch.schedule.intervalMs),
+                }
+            : current.schedule;
+        const runtime = patch.runtime
+            ? {
+                ...current.runtime,
+                ...patch.runtime,
+                sessionMode: 'persistent',
+                bindingStatus: patch.runtime.sessionId && !patch.runtime.sessionId.startsWith('cron-')
+                    ? 'bound'
+                    : current.runtime.bindingStatus,
+            }
+            : current.runtime;
+        return {
+            ...current,
+            ...(patch.name !== undefined ? { name: patch.name.trim() } : {}),
+            ...(patch.description !== undefined
+                ? patch.description.trim() ? { description: patch.description.trim() } : { description: undefined }
+                : {}),
+            ...(patch.status !== undefined ? { status: patch.status } : {}),
+            ...(patch.kind !== undefined ? { kind: patch.kind } : {}),
+            ...(patch.permanent !== undefined ? { permanent: patch.permanent || undefined } : {}),
+            ...(patch.expiresAt !== undefined ? { expiresAt: patch.expiresAt || undefined } : {}),
+            ...(patch.maxRuns !== undefined ? { maxRuns: patch.maxRuns || undefined } : {}),
+            schedule: nextSchedule,
+            ...(patch.action ? { action: patch.action } : {}),
+            runtime,
+        };
+    });
+}

package/plugins/cron-runner/src/types.js

@@ -0,0 +1 @@
+export {};

package/plugins/workflow-runner/commands/workflow.md

@@ -45,10 +45,10 @@ steps:
 - `allowed_tools: [Read, Write]` —— 收窄它能用的工具；**缺省给全量工具**（要真 agency）。
 - `output_schema: {...}` —— 要求结构化产出（provider-native JSON Schema），按字段 `capture`。
 - `context_files: [{ path, hint }]` —— 列出可读文件让它按需 Read（不 inline 内容）。
-- `maxTurns: <n>` —— 子循环最大轮数，默认 12。
+- `maxTurns: <n>` —— 子循环最大轮数，默认 25。
 - `capture` / `when` / `onError` —— 与其它动作 step 一致（agent 节点也能 `onError: recover` 被再救一次）。
 
-`agent` vs `skill`：`agent` 是 **inline、一次性**的有界子循环（miniReAct，轻、收敛快、产出受验证闸门把关）；
+`agent` vs `skill`：`agent` 是 **inline、一次性**的有界 TAOR 子循环（委托 runQuery，轻、收敛快、产出受验证闸门把关）；
 `skill` 是跑一个**外部 SKILL.md 定义、可复用**的完整 agent（runQuery）。需要复用同一套能力用 `skill`，
 临时让某步「自己想办法」用 `agent`。
 
@@ -75,7 +75,7 @@ steps:
 
 - `recover_hint: "<提示>"` —— 给恢复 agent 的提示（支持 `${var}` 插值），如 `"端口被占就换 3001 重试"`。
 - `allowed_tools: [Read, Bash]` —— 收窄恢复 agent 能用的工具；**缺省给全量工具**。
-- `maxTurns: <n>` —— 恢复子循环最大轮数，默认 12（够「诊断 + 探查 + 动手 + 验证」一圈）。
+- `maxTurns: <n>` —— 恢复子循环最大轮数，默认 25（够「诊断 + 探查 + 动手 + 验证」一圈）。
 
 示例：
 
@@ -91,7 +91,7 @@ steps:
 
 注意事项：
 
-- `onError` **只作用于动作 step**。控制流节点（branch / loop / vote / parallel 的条件或结构错误、
+- `onError` **只作用于动作 step**。控制流节点（branch / loop 的条件或结构错误、
   以及 `when` 表达式错误）**始终 halt** —— 那类是「作者写错了」，不是「运行期意外」，不走恢复。
 - `continue` vs `recover`：前者「放弃这步、盲目往下」，后者「想办法把这步做成、保住下游」。
   要扛住「预料之外」的情况，用 `recover`。

package/plugins/workflow-runner/commands/workflows.md

@@ -5,6 +5,6 @@ description: 列出当前 cwd 与插件包内可用的 YAML 工作流
 # /workflows
 
 由 workflow-runner 插件接管（plugin.ts.runCommand），扫描 cwd/workflows/ 与
-plugin 自带 examples/ 下的 *.yaml，把名称 + 一行描述列出来。
+packageRoot/workflows/（getResourceSearchPaths 双源，cwd 优先）下的 *.yaml，把名称 + 一行描述列出来。
 
 提示：用 `agent:` 节点可把开放式的一步交给有界 TAOR 子 agent 随机应变完成；用 `onError: recover` 可让失败节点交给恢复 agent 自适应救回（而非整条崩停）。二者共用同一套「自我验证 / 不伪造」纪律——详见 `/workflow` 命令说明。

package/plugins/workflow-runner/plugin.js

@@ -21,11 +21,13 @@ const api = {
             return;
         }
         if (commandName === 'workflow') {
+            const cwd = getWorkingDir();
             yield* runWorkflowFromCommand(args, {
                 provider: ctx.provider,
                 history: ctx.history,
                 signal: ctx.signal,
-                cwd: getWorkingDir(),
+                sessionState: ctx.sessionState,
+                cwd,
                 tools: ALL_TOOLS,
             });
             return;