@minko-ai/minko 0.1.0 → 0.1.1

package/dist/agent/cron.js

@@ -0,0 +1,326 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { minkoHome } from "../config/paths.js";
+import { WorkerRegistry } from "./workers.js";
+export class CronStore {
+    dir;
+    now;
+    constructor(dir = path.join(minkoHome(), 'cron'), now = Date.now) {
+        this.dir = dir;
+        this.now = now;
+    }
+    create(input) {
+        const name = input.name.trim();
+        const prompt = input.prompt.trim();
+        if (name.length === 0) {
+            throw new Error('缺少 name 参数');
+        }
+        if (prompt.length === 0) {
+            throw new Error('缺少 prompt 参数');
+        }
+        const everyMinutes = clampMinutes(input.everyMinutes);
+        const now = this.now();
+        const record = {
+            id: 'c-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6),
+            name,
+            prompt,
+            everyMinutes,
+            enabled: true,
+            allowWrite: input.allowWrite === true,
+            cwd: input.cwd?.trim() || undefined,
+            nextRunAt: new Date(now + everyMinutes * 60_000).toISOString(),
+            createdAt: new Date(now).toISOString(),
+            updatedAt: new Date(now).toISOString(),
+        };
+        this.save(record);
+        return record;
+    }
+    get(id) {
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.fileFor(id), 'utf8'));
+            return parseRecord(id, raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    list() {
+        let names;
+        try {
+            names = fs.readdirSync(this.dir);
+        }
+        catch {
+            return [];
+        }
+        const records = [];
+        for (const name of names) {
+            if (!name.endsWith('.json')) {
+                continue;
+            }
+            const id = name.slice(0, -'.json'.length);
+            if (!/^[A-Za-z0-9._-]+$/.test(id)) {
+                continue;
+            }
+            const record = this.get(id);
+            if (record) {
+                records.push(record);
+            }
+        }
+        records.sort((a, b) => a.nextRunAt.localeCompare(b.nextRunAt));
+        return records;
+    }
+    save(record) {
+        try {
+            fs.mkdirSync(this.dir, { recursive: true });
+            const file = this.fileFor(record.id);
+            const payload = JSON.stringify({
+                ...record,
+                updatedAt: new Date(this.now()).toISOString(),
+            }, null, 2);
+            const temporary = file + '.tmp';
+            fs.writeFileSync(temporary, payload, 'utf8');
+            try {
+                fs.renameSync(temporary, file);
+            }
+            catch {
+                fs.writeFileSync(file, payload, 'utf8');
+                try {
+                    fs.unlinkSync(temporary);
+                }
+                catch { /* best effort */ }
+            }
+        }
+        catch {
+            // Scheduling is advisory.
+        }
+    }
+    remove(id) {
+        try {
+            fs.unlinkSync(this.fileFor(id));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    fileFor(id) {
+        if (!/^[A-Za-z0-9._-]+$/.test(id)) {
+            throw new Error('非法的 cron id');
+        }
+        return path.join(this.dir, id + '.json');
+    }
+}
+/** Runs due cron entries as background workers while the process is alive. */
+export class CronScheduler {
+    workers;
+    store;
+    now;
+    intervalMs;
+    onLog;
+    timer = null;
+    constructor(options) {
+        this.workers = options.workers;
+        this.store = options.store ?? new CronStore(options.storeDir);
+        this.now = options.now ?? Date.now;
+        this.intervalMs = options.intervalMs ?? 60_000;
+        this.onLog = options.onLog ?? (() => { });
+    }
+    getStore() {
+        return this.store;
+    }
+    start() {
+        if (this.timer) {
+            return;
+        }
+        this.timer = setInterval(() => this.tick(), this.intervalMs);
+        this.timer.unref?.();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    tick() {
+        const now = this.now();
+        const started = [];
+        for (const record of this.store.list()) {
+            if (!record.enabled) {
+                continue;
+            }
+            if (Date.parse(record.nextRunAt) > now) {
+                continue;
+            }
+            if (record.lastWorkerId) {
+                const worker = this.workers.get(record.lastWorkerId);
+                if (worker && (worker.state === 'running' || worker.state === 'queued')) {
+                    continue;
+                }
+            }
+            const worker = this.workers.create({
+                prompt: record.prompt,
+                name: 'cron:' + record.name,
+                cwd: record.cwd,
+                allowWrite: record.allowWrite,
+            });
+            record.lastRunAt = new Date(now).toISOString();
+            record.lastWorkerId = worker.id;
+            record.nextRunAt = new Date(now + record.everyMinutes * 60_000).toISOString();
+            this.store.save(record);
+            this.onLog('cron ' + record.name + ' → worker ' + worker.id);
+            started.push(record);
+        }
+        return started;
+    }
+    runNow(id) {
+        const record = this.store.get(id);
+        if (!record) {
+            throw new Error('找不到 cron：' + id);
+        }
+        const now = this.now();
+        const worker = this.workers.create({
+            prompt: record.prompt,
+            name: 'cron:' + record.name,
+            cwd: record.cwd,
+            allowWrite: record.allowWrite,
+        });
+        record.lastRunAt = new Date(now).toISOString();
+        record.lastWorkerId = worker.id;
+        record.nextRunAt = new Date(now + record.everyMinutes * 60_000).toISOString();
+        this.store.save(record);
+        return record;
+    }
+}
+export function createCronTools(scheduler) {
+    const create = {
+        readOnly: true,
+        spec: {
+            name: 'cron_create',
+            description: '创建一个定时后台任务（按分钟间隔），在交互模式或后台服务运行期间自动启动 worker。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    prompt: { type: 'string' },
+                    every_minutes: { type: 'number', description: '1-10080 分钟' },
+                    allow_write: { type: 'boolean' },
+                },
+                required: ['name', 'prompt', 'every_minutes'],
+                additionalProperties: false,
+            },
+        },
+        async run(args, ctx) {
+            const allowWrite = args.allow_write === true;
+            if (allowWrite && ctx.planMode) {
+                throw new Error('计划模式不能创建写入 cron；先提交计划或退出计划模式');
+            }
+            const record = scheduler.getStore().create({
+                name: typeof args.name === 'string' ? args.name : '',
+                prompt: typeof args.prompt === 'string' ? args.prompt : '',
+                everyMinutes: typeof args.every_minutes === 'number' ? args.every_minutes : 0,
+                allowWrite,
+                cwd: ctx.cwd,
+            });
+            return '已创建 cron ' + record.id + '（' + record.name + '，每 '
+                + record.everyMinutes + ' 分钟）';
+        },
+    };
+    const list = {
+        readOnly: true,
+        spec: {
+            name: 'cron_list',
+            description: '列出定时任务及下次运行时间。',
+            parameters: { type: 'object', properties: {}, additionalProperties: false },
+        },
+        async run() {
+            const records = scheduler.getStore().list();
+            if (records.length === 0) {
+                return '还没有 cron。';
+            }
+            return records.map((record) => record.id + ' [' + (record.enabled ? '启用' : '停用') + '] '
+                + record.name + ' · 每 ' + record.everyMinutes + ' 分钟 · 下次 '
+                + record.nextRunAt.slice(0, 16).replace('T', ' ')).join('\n');
+        },
+    };
+    const remove = {
+        readOnly: true,
+        spec: {
+            name: 'cron_delete',
+            description: '删除一个定时任务。',
+            parameters: {
+                type: 'object',
+                properties: { id: { type: 'string' } },
+                required: ['id'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            const id = requiredId(args);
+            if (!scheduler.getStore().remove(id)) {
+                throw new Error('找不到 cron：' + id);
+            }
+            return '已删除 cron ' + id;
+        },
+    };
+    const run = {
+        readOnly: true,
+        spec: {
+            name: 'cron_run',
+            description: '立即运行一次定时任务。',
+            parameters: {
+                type: 'object',
+                properties: { id: { type: 'string' } },
+                required: ['id'],
+                additionalProperties: false,
+            },
+        },
+        async run(args, ctx) {
+            const id = requiredId(args);
+            const record = scheduler.getStore().get(id);
+            if (!record) {
+                throw new Error('找不到 cron：' + id);
+            }
+            if (record.allowWrite && ctx.planMode) {
+                throw new Error('计划模式不能运行写入 cron；先提交计划或退出计划模式');
+            }
+            scheduler.runNow(id);
+            return '已触发 cron ' + id;
+        },
+    };
+    return [create, list, remove, run];
+}
+function clampMinutes(value) {
+    if (!Number.isFinite(value)) {
+        throw new Error('every_minutes 必须是数字');
+    }
+    return Math.min(10_080, Math.max(1, Math.floor(value)));
+}
+function requiredId(args) {
+    const id = typeof args.id === 'string' ? args.id.trim() : '';
+    if (id.length === 0) {
+        throw new Error('缺少 id 参数');
+    }
+    return id;
+}
+function parseRecord(id, raw) {
+    if (typeof raw.name !== 'string' || typeof raw.prompt !== 'string'
+        || typeof raw.everyMinutes !== 'number' || typeof raw.enabled !== 'boolean'
+        || typeof raw.allowWrite !== 'boolean' || typeof raw.nextRunAt !== 'string'
+        || typeof raw.createdAt !== 'string' || typeof raw.updatedAt !== 'string') {
+        return null;
+    }
+    return {
+        id,
+        name: raw.name,
+        prompt: raw.prompt,
+        everyMinutes: raw.everyMinutes,
+        enabled: raw.enabled,
+        allowWrite: raw.allowWrite,
+        cwd: typeof raw.cwd === 'string' ? raw.cwd : undefined,
+        lastRunAt: typeof raw.lastRunAt === 'string' ? raw.lastRunAt : undefined,
+        nextRunAt: raw.nextRunAt,
+        lastWorkerId: typeof raw.lastWorkerId === 'string' ? raw.lastWorkerId : undefined,
+        createdAt: raw.createdAt,
+        updatedAt: raw.updatedAt,
+    };
+}

package/dist/agent/hooks.js

@@ -0,0 +1,211 @@
+import { spawn } from 'node:child_process';
+const DEFAULT_TIMEOUT_MS = 10_000;
+/** Tool-name matcher: exact, `*` wildcard, or comma/pipe separated alternatives. */
+export function hookMatches(matcher, toolName) {
+    if (matcher === undefined || matcher.trim().length === 0) {
+        return true;
+    }
+    return matcher
+        .split(/[,|]/)
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .some((part) => globToRegExp(part).test(toolName));
+}
+export async function runHookEvent(options) {
+    const outcome = {
+        denied: false,
+        failed: false,
+        cancelled: false,
+        messages: [],
+    };
+    const commands = commandsFor(options.config, options.event, options.toolName);
+    if (commands.length === 0) {
+        return outcome;
+    }
+    if (options.signal?.aborted) {
+        outcome.cancelled = true;
+        outcome.messages.push('hook 已取消');
+        return outcome;
+    }
+    const payload = JSON.stringify({
+        event: options.event,
+        tool_name: options.toolName,
+        tool_input: parseInput(options.toolInput),
+        ...(options.toolOutput === undefined ? {} : { tool_output: options.toolOutput }),
+        is_error: Boolean(options.isError),
+    });
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    for (const command of commands) {
+        const result = await runCommand(command.command, payload, timeoutMs, options.signal, command.cwd);
+        if (result.cancelled) {
+            outcome.cancelled = true;
+            outcome.messages.push('hook 已取消');
+            break;
+        }
+        if (result.timedOut) {
+            outcome.failed = true;
+            outcome.messages.push('hook 超时（' + timeoutMs + 'ms）：' + command.command);
+            break;
+        }
+        if (result.code !== 0) {
+            outcome.failed = true;
+            const detail = result.stderr.trim() || result.stdout.trim() || 'exit ' + String(result.code);
+            outcome.messages.push('hook 失败：' + detail);
+            break;
+        }
+        const parsed = parseHookOutput(result.stdout);
+        outcome.messages.push(...parsed.messages);
+        if (parsed.denied) {
+            outcome.denied = true;
+        }
+        if (parsed.permission) {
+            outcome.permission = parsed.permission;
+        }
+        if (parsed.permissionReason) {
+            outcome.permissionReason = parsed.permissionReason;
+        }
+        if (parsed.updatedInput !== undefined) {
+            outcome.updatedInput = parsed.updatedInput;
+        }
+        if (outcome.denied) {
+            break;
+        }
+    }
+    return outcome;
+}
+function commandsFor(config, event, toolName) {
+    const entries = config?.[event] ?? [];
+    const commands = [];
+    for (const entry of entries) {
+        if (typeof entry === 'string') {
+            commands.push({ type: 'command', command: entry });
+            continue;
+        }
+        if (!hookMatches(entry.matcher, toolName)) {
+            continue;
+        }
+        for (const hook of entry.hooks) {
+            if (hook.type === undefined || hook.type === 'command') {
+                commands.push(hook);
+            }
+        }
+    }
+    return commands;
+}
+function parseHookOutput(stdout) {
+    const trimmed = stdout.trim();
+    const parsed = { denied: false, messages: [] };
+    if (trimmed.length === 0) {
+        return parsed;
+    }
+    let root;
+    try {
+        root = JSON.parse(trimmed);
+    }
+    catch {
+        parsed.messages.push(trimmed);
+        return parsed;
+    }
+    if (root === null || typeof root !== 'object' || Array.isArray(root)) {
+        parsed.messages.push(trimmed);
+        return parsed;
+    }
+    const record = root;
+    if (record.continue === false || record.decision === 'block') {
+        parsed.denied = true;
+    }
+    if (typeof record.systemMessage === 'string') {
+        parsed.messages.push(record.systemMessage);
+    }
+    if (typeof record.reason === 'string') {
+        parsed.messages.push(record.reason);
+    }
+    const specific = record.hookSpecificOutput;
+    if (specific !== null && typeof specific === 'object') {
+        const output = specific;
+        if (typeof output.additionalContext === 'string') {
+            parsed.messages.push(output.additionalContext);
+        }
+        if (output.permissionDecision === 'allow'
+            || output.permissionDecision === 'deny'
+            || output.permissionDecision === 'ask') {
+            parsed.permission = output.permissionDecision;
+        }
+        if (typeof output.permissionDecisionReason === 'string') {
+            parsed.permissionReason = output.permissionDecisionReason;
+        }
+        if (output.updatedInput !== undefined) {
+            parsed.updatedInput = JSON.stringify(output.updatedInput);
+        }
+    }
+    if (parsed.messages.length === 0 && !parsed.denied && !parsed.permission) {
+        parsed.messages.push(trimmed);
+    }
+    return parsed;
+}
+function parseInput(raw) {
+    try {
+        const value = JSON.parse(raw);
+        return value !== null && typeof value === 'object' ? value : raw;
+    }
+    catch {
+        return raw;
+    }
+}
+function runCommand(command, payload, timeoutMs, signal, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn(command, {
+            shell: true,
+            windowsHide: true,
+            cwd,
+            env: { ...process.env, MINKO: '1' },
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let timer;
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+            if (signal) {
+                signal.removeEventListener('abort', onAbort);
+            }
+            resolve(result);
+        };
+        const onAbort = () => {
+            child.kill();
+            finish({ code: null, stdout, stderr, timedOut: false, cancelled: true });
+        };
+        if (signal) {
+            signal.addEventListener('abort', onAbort, { once: true });
+        }
+        timer = setTimeout(() => {
+            child.kill();
+            finish({ code: null, stdout, stderr, timedOut: true, cancelled: false });
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => { stdout += chunk.toString('utf8'); });
+        child.stderr.on('data', (chunk) => { stderr += chunk.toString('utf8'); });
+        // Hooks are free to ignore stdin; a broken pipe must not crash the agent.
+        child.stdin.on('error', () => { });
+        child.on('error', (error) => {
+            stderr += error.message;
+            finish({ code: null, stdout, stderr, timedOut: false, cancelled: false });
+        });
+        child.on('close', (code) => {
+            finish({ code, stdout, stderr, timedOut: false, cancelled: false });
+        });
+        child.stdin.end(payload);
+    });
+}
+function globToRegExp(pattern) {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    return new RegExp('^' + escaped + '$', 'i');
+}