harness-async 0.1.0

package/dist/src/core/run-manager.js

@@ -0,0 +1,265 @@
+import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { appendEvent } from './event-log.js';
+import { findTaskLocation, getTask, updateTaskStatus } from './task-manager.js';
+import { resolveStoreDir } from './store.js';
+import { runSchema } from '../types/index.js';
+const META_FILE = 'meta.json';
+const PROMPT_FILE = 'prompt.txt';
+const STDOUT_FILE = 'stdout.log';
+const EXIT_CODE_FILE = 'exit.code';
+export async function startRun(input) {
+    const task = await getTask({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        id: input.taskId,
+        scope: input.scope ?? 'project',
+    });
+    const location = await findTaskLocation({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        id: input.taskId,
+        scope: input.scope ?? 'project',
+    });
+    if (!location) {
+        throw new Error(`Task ${input.taskId} not found`);
+    }
+    const now = input.now ?? new Date().toISOString();
+    const runsRoot = join(location.storeDir, 'runs');
+    await mkdir(runsRoot, { recursive: true });
+    const sequence = (await listRunsInStore(location.storeDir, input.taskId)).length + 1;
+    const runId = `${toFilesystemTimestamp(now)}-task-${String(input.taskId).padStart(3, '0')}-run-${sequence}`;
+    const runDir = join(runsRoot, runId);
+    const promptPath = join(runDir, PROMPT_FILE);
+    const stdoutPath = join(runDir, STDOUT_FILE);
+    const exitCodePath = join(runDir, EXIT_CODE_FILE);
+    const metaPath = join(runDir, META_FILE);
+    const run = runSchema.parse({
+        id: runId,
+        taskId: input.taskId,
+        tool: input.tool,
+        status: 'running',
+        tmuxSession: `ha-task-${String(input.taskId).padStart(3, '0')}-run-${sequence}`,
+        startedAt: now,
+        completedAt: null,
+        exitCode: null,
+        directory: input.directory,
+        scope: task.scope,
+        runDir,
+        stdoutPath,
+        exitCodePath,
+        promptPath,
+    });
+    await mkdir(runDir, { recursive: true });
+    await writeFile(promptPath, input.prompt ?? '', 'utf8');
+    await writeFile(stdoutPath, '', 'utf8');
+    await writeFile(metaPath, `${JSON.stringify(run, null, 2)}\n`, 'utf8');
+    try {
+        await updateTaskStatus({
+            cwd: input.cwd,
+            homeDir: input.homeDir,
+            id: input.taskId,
+            scope: task.scope,
+            status: 'running',
+            actor: input.tool,
+        });
+        await appendEvent(location.storeDir, {
+            ts: now,
+            type: 'run.started',
+            taskId: input.taskId,
+            actor: input.tool,
+            detail: {
+                runId,
+                tool: input.tool,
+                session: run.tmuxSession,
+            },
+        });
+    }
+    catch (error) {
+        await rm(runDir, { recursive: true, force: true });
+        throw error;
+    }
+    return run;
+}
+export async function completeRun(input) {
+    const located = await findRun(input);
+    const now = input.now ?? new Date().toISOString();
+    const nextStatus = input.exitCode === 0 ? 'completed' : 'failed';
+    const nextRun = runSchema.parse({
+        ...located.run,
+        status: nextStatus,
+        completedAt: now,
+        exitCode: input.exitCode,
+    });
+    await writeRunMeta(nextRun);
+    const task = await getTask({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        id: nextRun.taskId,
+        scope: nextRun.scope,
+    });
+    const targetStatus = input.exitCode === 0
+        ? task.level === 'L2'
+            ? 'waiting-review'
+            : 'completed'
+        : 'failed';
+    if (task.status === 'running') {
+        await updateTaskStatus({
+            cwd: input.cwd,
+            homeDir: input.homeDir,
+            id: nextRun.taskId,
+            scope: nextRun.scope,
+            status: targetStatus,
+            actor: nextRun.tool,
+            reason: input.exitCode === 0 ? undefined : `Run ${nextRun.id} exited with code ${input.exitCode}`,
+        });
+    }
+    await appendEvent(located.storeDir, {
+        ts: now,
+        type: input.exitCode === 0 ? 'run.completed' : 'run.failed',
+        taskId: nextRun.taskId,
+        actor: nextRun.tool,
+        detail: {
+            runId: nextRun.id,
+            exitCode: input.exitCode,
+        },
+    });
+    return nextRun;
+}
+export async function listRuns(input) {
+    const storeDirs = await resolveRunStores(input);
+    const runs = (await Promise.all(storeDirs.map(async (storeDir) => listRunsInStore(storeDir, input.taskId)))).flat();
+    return [...runs].sort((left, right) => right.startedAt.localeCompare(left.startedAt));
+}
+export async function getRun(input) {
+    const located = await findRun({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        runId: input.runId,
+        scope: input.scope,
+    });
+    return located.run;
+}
+export async function readRunOutput(run) {
+    try {
+        return await readFile(run.stdoutPath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return '';
+        }
+        throw error;
+    }
+}
+export async function readRunExitCode(run) {
+    try {
+        const raw = await readFile(run.exitCodePath, 'utf8');
+        const trimmed = raw.trim();
+        return trimmed.length > 0 ? Number(trimmed) : null;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function updateRunStatus(run, status, options = {}) {
+    const nextRun = runSchema.parse({
+        ...run,
+        status,
+        exitCode: options.exitCode ?? run.exitCode,
+        completedAt: options.completedAt ?? run.completedAt,
+    });
+    await writeRunMeta(nextRun);
+    return nextRun;
+}
+async function writeRunMeta(run) {
+    await mkdir(run.runDir, { recursive: true });
+    await writeFile(join(run.runDir, META_FILE), `${JSON.stringify(run, null, 2)}\n`, 'utf8');
+}
+async function findRun(input) {
+    const storeDirs = await resolveRunStores({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        scope: input.scope ?? 'all',
+    });
+    for (const storeDir of storeDirs) {
+        const filePath = join(storeDir, 'runs', input.runId, META_FILE);
+        try {
+            const raw = await readFile(filePath, 'utf8');
+            return {
+                run: runSchema.parse(JSON.parse(raw)),
+                storeDir,
+            };
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error(`Run ${input.runId} not found`);
+}
+async function listRunsInStore(storeDir, taskId) {
+    const runsDir = join(storeDir, 'runs');
+    try {
+        const entries = await readdir(runsDir, { withFileTypes: true });
+        const runs = await Promise.all(entries
+            .filter((entry) => entry.isDirectory())
+            .map(async (entry) => {
+            const raw = await readFile(join(runsDir, entry.name, META_FILE), 'utf8');
+            return runSchema.parse(JSON.parse(raw));
+        }));
+        return runs.filter((run) => (taskId ? run.taskId === taskId : true));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+async function resolveRunStores(input) {
+    const candidates = [
+        {
+            scope: 'project',
+            baseDir: resolveStoreDir({
+                cwd: input.cwd,
+                homeDir: input.homeDir,
+                scope: 'project',
+            }),
+        },
+        {
+            scope: 'global',
+            baseDir: resolveStoreDir({
+                cwd: input.cwd,
+                homeDir: input.homeDir,
+                scope: 'global',
+            }),
+        },
+    ];
+    if (input.scope === 'project') {
+        return [candidates[0].baseDir];
+    }
+    if (input.scope === 'global') {
+        return [candidates[1].baseDir];
+    }
+    return candidates.map((candidate) => candidate.baseDir);
+}
+function toFilesystemTimestamp(value) {
+    return new Date(value).toISOString().replace(/:/g, '-');
+}
+export function metaFilename() {
+    return META_FILE;
+}
+export function outputFilename() {
+    return STDOUT_FILE;
+}
+export function exitCodeFilename() {
+    return EXIT_CODE_FILE;
+}
+export function promptFilename() {
+    return PROMPT_FILE;
+}

package/dist/src/core/run-orchestrator.js

@@ -0,0 +1,193 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { relative } from 'node:path';
+import { createAgentAdapter } from '../adapters/index.js';
+import { completeRun, getRun, readRunOutput, startRun } from './run-manager.js';
+import { getTask, listRunnableTasks, findTaskLocation } from './task-manager.js';
+import { attachTmuxSession } from './tmux.js';
+export async function startTaskRun(input) {
+    const task = input.auto
+        ? await pickRunnableTask(input)
+        : await getTask({
+            cwd: input.cwd,
+            homeDir: input.homeDir,
+            id: input.taskId ?? 0,
+            scope: input.scope ?? 'project',
+        });
+    const adapter = createAgentAdapter(input.tool, {
+        claudeBin: process.env.HA_CLAUDE_BIN,
+        codexBin: process.env.HA_CODEX_BIN,
+        tmuxBin: process.env.HA_TMUX_BIN,
+    });
+    const report = await adapter.detect();
+    if (!report.available) {
+        throw new Error(`Unable to find ${input.tool} on PATH`);
+    }
+    const prompt = await buildRunPrompt(task, input.cwd, input.homeDir);
+    const run = await startRun({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        taskId: task.id,
+        tool: input.tool,
+        directory: task.project ?? input.cwd,
+        prompt,
+        scope: task.scope,
+    });
+    const context = await buildRunContext(run, input.cwd, input.homeDir);
+    try {
+        await adapter.start(run, context);
+        return run;
+    }
+    catch (error) {
+        await completeRun({
+            cwd: input.cwd,
+            homeDir: input.homeDir,
+            runId: run.id,
+            exitCode: 1,
+        });
+        throw error;
+    }
+}
+export async function syncRunState(context, runId) {
+    const run = await getRun({
+        cwd: context.cwd,
+        homeDir: context.homeDir,
+        runId,
+        scope: 'all',
+    });
+    if (run.status !== 'running') {
+        return run;
+    }
+    const adapter = createAgentAdapter(run.tool, {
+        claudeBin: process.env.HA_CLAUDE_BIN,
+        codexBin: process.env.HA_CODEX_BIN,
+        tmuxBin: process.env.HA_TMUX_BIN,
+    });
+    const snapshot = await adapter.collect(run);
+    if (snapshot.output.trim().length > 0) {
+        const currentOutput = await readRunOutput(run);
+        if (currentOutput.trim().length === 0) {
+            await writeFile(run.stdoutPath, snapshot.output, 'utf8');
+        }
+    }
+    if (!snapshot.active && snapshot.exitCode !== null) {
+        return completeRun({
+            cwd: context.cwd,
+            homeDir: context.homeDir,
+            runId,
+            exitCode: snapshot.exitCode,
+        });
+    }
+    return run;
+}
+export async function stopTaskRun(context, runId) {
+    const run = await getRun({
+        cwd: context.cwd,
+        homeDir: context.homeDir,
+        runId,
+        scope: 'all',
+    });
+    const adapter = createAgentAdapter(run.tool, {
+        claudeBin: process.env.HA_CLAUDE_BIN,
+        codexBin: process.env.HA_CODEX_BIN,
+        tmuxBin: process.env.HA_TMUX_BIN,
+    });
+    await adapter.stop(run);
+    return completeRun({
+        cwd: context.cwd,
+        homeDir: context.homeDir,
+        runId,
+        exitCode: 130,
+    });
+}
+export async function collectRunOutput(context, runId) {
+    const run = await syncRunState(context, runId);
+    const adapter = createAgentAdapter(run.tool, {
+        claudeBin: process.env.HA_CLAUDE_BIN,
+        codexBin: process.env.HA_CODEX_BIN,
+        tmuxBin: process.env.HA_TMUX_BIN,
+    });
+    const snapshot = await adapter.collect(run);
+    return snapshot.output || (await readRunOutput(run));
+}
+export async function getRunAttachCommand(context, runId) {
+    const run = await getRun({
+        cwd: context.cwd,
+        homeDir: context.homeDir,
+        runId,
+        scope: 'all',
+    });
+    return attachTmuxSession(run.tmuxSession);
+}
+export async function buildRunContext(run, cwd, homeDir) {
+    const task = await getTask({
+        cwd,
+        homeDir,
+        id: run.taskId,
+        scope: run.scope,
+    });
+    const prompt = await readRunOutputFile(run.promptPath);
+    const location = await findTaskLocation({
+        cwd,
+        homeDir,
+        id: run.taskId,
+        scope: run.scope,
+    });
+    if (!location) {
+        throw new Error(`Task ${run.taskId} not found`);
+    }
+    return {
+        cwd,
+        homeDir,
+        storeDir: location.storeDir,
+        runDir: run.runDir,
+        stdoutPath: run.stdoutPath,
+        exitCodePath: run.exitCodePath,
+        promptPath: run.promptPath,
+        task,
+        prompt,
+    };
+}
+export async function buildRunPrompt(task, cwd, homeDir) {
+    const location = await findTaskLocation({
+        cwd,
+        homeDir,
+        id: task.id,
+        scope: task.scope,
+    });
+    if (!location) {
+        throw new Error(`Task ${task.id} not found`);
+    }
+    const taskPath = relative(cwd, location.filePath) || location.filePath;
+    return [
+        `根据任务文档执行任务 #${task.id}: ${task.title}。`,
+        `任务文件: ${taskPath}`,
+        `完成后运行: ha task complete ${task.id}`,
+        `如果遇到问题，运行: ha task fail ${task.id} --reason "<具体原因>"`,
+        '',
+        task.body || 'No additional task body.',
+    ].join('\n');
+}
+async function pickRunnableTask(input) {
+    const tasks = await listRunnableTasks({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        scope: input.scope ?? 'project',
+        level: 'L1',
+    });
+    const task = tasks.find((entry) => entry.assignee === input.tool || entry.assignee === 'auto');
+    if (!task) {
+        throw new Error('No runnable L1 task is available');
+    }
+    return task;
+}
+async function readRunOutputFile(filePath) {
+    try {
+        return await readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return '';
+        }
+        throw error;
+    }
+}

package/dist/src/core/scheduler.js

@@ -0,0 +1,106 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { appendEvent } from './event-log.js';
+import { resolveStoreDir, withLock } from './store.js';
+import { scheduleSchema } from '../types/index.js';
+const SCHEDULE_FILE = 'schedule.json';
+function resolveGlobalStore(context) {
+    return resolveStoreDir({
+        cwd: context.cwd,
+        homeDir: context.homeDir,
+        scope: 'global',
+    });
+}
+async function readScheduleFile(storeDir) {
+    const filePath = join(storeDir, SCHEDULE_FILE);
+    try {
+        const raw = await readFile(filePath, 'utf8');
+        return scheduleSchema.array().parse(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+async function writeScheduleFile(storeDir, schedules) {
+    const filePath = join(storeDir, SCHEDULE_FILE);
+    await writeFile(filePath, `${JSON.stringify(scheduleSchema.array().parse(schedules), null, 2)}\n`, 'utf8');
+}
+export async function addSchedule(input) {
+    const storeDir = resolveGlobalStore(input);
+    const lockPath = join(storeDir, SCHEDULE_FILE);
+    return withLock(lockPath, async () => {
+        const schedules = await readScheduleFile(storeDir);
+        if (schedules.some((entry) => entry.name === input.name)) {
+            throw new Error(`Schedule ${input.name} already exists`);
+        }
+        const schedule = scheduleSchema.parse({
+            name: input.name,
+            cron: input.cron,
+            command: input.command,
+            enabled: true,
+            lastTriggered: null,
+        });
+        schedules.push(schedule);
+        await writeScheduleFile(storeDir, schedules);
+        return schedule;
+    });
+}
+export async function listSchedules(input) {
+    return readScheduleFile(resolveGlobalStore(input));
+}
+export async function removeSchedule(input) {
+    const storeDir = resolveGlobalStore(input);
+    const lockPath = join(storeDir, SCHEDULE_FILE);
+    await withLock(lockPath, async () => {
+        const schedules = await readScheduleFile(storeDir);
+        const filtered = schedules.filter((entry) => entry.name !== input.name);
+        if (filtered.length === schedules.length) {
+            throw new Error(`Schedule ${input.name} not found`);
+        }
+        await writeScheduleFile(storeDir, filtered);
+    });
+}
+export async function triggerSchedule(input) {
+    const storeDir = resolveGlobalStore(input);
+    const lockPath = join(storeDir, SCHEDULE_FILE);
+    const schedule = await withLock(lockPath, async () => {
+        const schedules = await readScheduleFile(storeDir);
+        const target = schedules.find((entry) => entry.name === input.name);
+        if (!target) {
+            throw new Error(`Schedule ${input.name} not found`);
+        }
+        target.lastTriggered = new Date().toISOString();
+        await writeScheduleFile(storeDir, schedules);
+        return target;
+    });
+    await runShellCommand(schedule.command, input.cwd);
+    await appendEvent(storeDir, {
+        ts: schedule.lastTriggered ?? new Date().toISOString(),
+        type: 'schedule.triggered',
+        actor: 'system',
+        detail: {
+            name: schedule.name,
+            command: schedule.command,
+        },
+    });
+}
+async function runShellCommand(command, cwd) {
+    await new Promise((resolve, reject) => {
+        const child = spawn('sh', ['-lc', command], {
+            cwd,
+            stdio: 'ignore',
+        });
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`Command failed with exit code ${code ?? -1}`));
+        });
+    });
+}

package/dist/src/core/sessions.js

@@ -0,0 +1,48 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+import { resolveStoreDir } from './store.js';
+const sessionRecordSchema = z.object({
+    taskId: z.number().int().positive(),
+    runId: z.string().min(1),
+    startedAt: z.string().datetime({ offset: true }),
+});
+const sessionsSchema = z.record(z.string(), sessionRecordSchema);
+function resolveSessionsPath(context) {
+    return join(resolveStoreDir({
+        cwd: context.cwd,
+        homeDir: context.homeDir,
+        scope: 'project',
+    }), 'sessions.json');
+}
+export async function readSessions(context) {
+    const filePath = resolveSessionsPath(context);
+    try {
+        const raw = await readFile(filePath, 'utf8');
+        return sessionsSchema.parse(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return {};
+        }
+        throw error;
+    }
+}
+export async function upsertSession(context, sessionId, record) {
+    const filePath = resolveSessionsPath(context);
+    const sessions = await readSessions(context);
+    sessions[sessionId] = sessionRecordSchema.parse(record);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(sessionsSchema.parse(sessions), null, 2)}\n`, 'utf8');
+}
+export async function getSession(context, sessionId) {
+    const sessions = await readSessions(context);
+    return sessions[sessionId] ?? null;
+}
+export async function removeSession(context, sessionId) {
+    const filePath = resolveSessionsPath(context);
+    const sessions = await readSessions(context);
+    delete sessions[sessionId];
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(sessionsSchema.parse(sessions), null, 2)}\n`, 'utf8');
+}