harness-async 0.1.0

package/dist/src/core/daemon.js

@@ -0,0 +1,375 @@
+import { execFile } from 'node:child_process';
+import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import chokidar from 'chokidar';
+import cron from 'node-cron';
+import { notifyTaskEvent } from '../cli/utils/notify.js';
+import { startTaskRun } from './run-orchestrator.js';
+import { triggerSchedule, listSchedules } from './scheduler.js';
+import { readConfig, readIndex, readTaskFile, resolveStoreDir } from './store.js';
+import { eventSchema } from '../types/index.js';
+const execFileAsync = promisify(execFile);
+const DAEMON_LABEL = 'com.harness-agent.daemon';
+export function resolveDaemonEntryPath(options) {
+    const cliEntry = options.cliEntry ?? process.argv[1];
+    const normalizedCliEntry = cliEntry?.replace(/\\/g, '/');
+    if (cliEntry && normalizedCliEntry?.endsWith('/dist/src/cli/index.js')) {
+        return resolve(dirname(cliEntry), '..', 'daemon.js');
+    }
+    if (cliEntry && normalizedCliEntry?.endsWith('/src/cli/index.ts')) {
+        return resolve(dirname(cliEntry), '..', '..', 'dist', 'src', 'daemon.js');
+    }
+    return resolve(options.cwd, 'dist', 'src', 'daemon.js');
+}
+export function resolveDaemonPaths(options) {
+    const homeDir = options.homeDir ?? process.env.HA_HOME ?? process.env.HOME;
+    if (!homeDir) {
+        throw new Error('Unable to resolve home directory for daemon');
+    }
+    const launchAgentsDir = options.launchAgentsDir ?? join(homeDir, 'Library', 'LaunchAgents');
+    const logsDir = options.logsDir ?? join(homeDir, 'Library', 'Logs', 'harness-async');
+    return {
+        homeDir,
+        launchAgentsDir,
+        logsDir,
+        plistPath: join(launchAgentsDir, `${DAEMON_LABEL}.plist`),
+        stdoutPath: join(logsDir, 'daemon.out.log'),
+        stderrPath: join(logsDir, 'daemon.err.log'),
+    };
+}
+export function renderLaunchdPlist(options) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${DAEMON_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${options.nodePath}</string>
+    <string>${options.daemonEntry}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${options.cwd}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HA_HOME</key>
+    <string>${options.paths.homeDir}</string>
+    <key>HA_PROJECT_ROOT</key>
+    <string>${options.cwd}</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${options.paths.stdoutPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${options.paths.stderrPath}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+</dict>
+</plist>
+`;
+}
+export async function startLaunchdDaemon(options) {
+    const paths = resolveDaemonPaths(options);
+    const runLaunchctl = options.runLaunchctl ?? createLaunchctlRunner(options.launchctlBin);
+    const daemonEntry = options.daemonEntry ?? resolveDaemonEntryPath({ cwd: options.cwd });
+    const nodePath = options.nodePath ?? process.execPath;
+    await mkdir(paths.launchAgentsDir, { recursive: true });
+    await mkdir(paths.logsDir, { recursive: true });
+    await writeFile(paths.plistPath, renderLaunchdPlist({
+        cwd: options.cwd,
+        daemonEntry,
+        nodePath,
+        paths,
+    }), 'utf8');
+    await runLaunchctl(['load', '-w', paths.plistPath]);
+    return paths;
+}
+export async function startDockerDaemon(options) {
+    const paths = resolveDaemonPaths(options);
+    const runDocker = options.runDocker ?? createDockerRunner(options.dockerBin);
+    const imageName = options.imageName ?? 'ha-daemon';
+    const containerName = options.containerName ?? 'ha-daemon';
+    await runDocker(['build', '-t', imageName, '.'], { cwd: options.cwd });
+    await runDocker([
+        'run',
+        '-d',
+        '--name',
+        containerName,
+        '-v',
+        `${join(paths.homeDir, '.ha')}:/data`,
+        '-e',
+        'HA_HOME=/data',
+        '-e',
+        'HA_PROJECT_ROOT=/app',
+        '-p',
+        '3777:3777',
+        imageName,
+    ], { cwd: options.cwd });
+}
+export async function stopLaunchdDaemon(options) {
+    const paths = resolveDaemonPaths(options);
+    const runLaunchctl = options.runLaunchctl ?? createLaunchctlRunner(options.launchctlBin);
+    try {
+        await access(paths.plistPath);
+        await runLaunchctl(['unload', '-w', paths.plistPath]);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    await rm(paths.plistPath, { force: true });
+    return paths;
+}
+export async function stopDockerDaemon(options) {
+    const runDocker = options.runDocker ?? createDockerRunner(options.dockerBin);
+    const containerName = options.containerName ?? 'ha-daemon';
+    await runDocker(['stop', containerName], { cwd: options.cwd });
+    await runDocker(['rm', containerName], { cwd: options.cwd });
+}
+export async function getDaemonStatus(options) {
+    const paths = resolveDaemonPaths(options);
+    const runLaunchctl = options.runLaunchctl ?? createLaunchctlRunner(options.launchctlBin);
+    const plistExists = await fileExists(paths.plistPath);
+    try {
+        const result = await runLaunchctl(['list', DAEMON_LABEL]);
+        const pidMatch = result.stdout.match(/"PID"\s*=\s*(\d+)/);
+        if (pidMatch) {
+            return {
+                ...paths,
+                state: 'running',
+                pid: Number(pidMatch[1]),
+            };
+        }
+        return {
+            ...paths,
+            state: 'loaded',
+            pid: null,
+        };
+    }
+    catch {
+        return {
+            ...paths,
+            state: plistExists ? 'installed' : 'stopped',
+            pid: null,
+        };
+    }
+}
+export async function readDaemonLogs(options) {
+    const paths = resolveDaemonPaths(options);
+    return {
+        stdout: await readFileIfExists(paths.stdoutPath),
+        stderr: await readFileIfExists(paths.stderrPath),
+    };
+}
+export async function startDaemonRuntime(options) {
+    const stores = resolveRuntimeStores(options.cwd, options.homeDir);
+    const schedules = await listSchedules({
+        cwd: options.cwd,
+        homeDir: options.homeDir,
+    });
+    const jobs = schedules
+        .filter((schedule) => schedule.enabled)
+        .map((schedule) => cron.schedule(schedule.cron, () => {
+        void triggerSchedule({
+            cwd: options.cwd,
+            homeDir: options.homeDir,
+            name: schedule.name,
+        }).catch((error) => {
+            options.logger?.(`Failed to trigger schedule ${schedule.name}: ${error.message}`);
+        });
+    }));
+    const processedLines = new Map();
+    const watchers = stores.map((storeDir) => chokidar.watch(join(storeDir, 'events.ndjson'), {
+        ignoreInitial: false,
+        awaitWriteFinish: {
+            stabilityThreshold: 50,
+            pollInterval: 10,
+        },
+    }));
+    const processEvents = async (storeDir) => {
+        const eventsPath = join(storeDir, 'events.ndjson');
+        try {
+            const raw = await readFile(eventsPath, 'utf8');
+            const lines = raw.split('\n').filter(Boolean);
+            const freshLines = lines.slice(processedLines.get(eventsPath) ?? 0);
+            processedLines.set(eventsPath, lines.length);
+            for (const line of freshLines) {
+                const event = eventSchema.parse(JSON.parse(line));
+                await options.broadcastEvent?.(event);
+                const notification = await mapEventToNotification(storeDir, event);
+                if (notification) {
+                    await notifyTaskEvent(notification, options.notifyAdapter);
+                }
+                await maybeAutoStartUnlockedTask(storeDir, event, options);
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return;
+            }
+            options.logger?.(`Failed to process daemon events: ${error.message}`);
+        }
+    };
+    for (const [index, watcher] of watchers.entries()) {
+        const storeDir = stores[index];
+        watcher.on('add', () => {
+            void processEvents(storeDir);
+        });
+        watcher.on('change', () => {
+            void processEvents(storeDir);
+        });
+        await processEvents(storeDir);
+    }
+    return {
+        async stop() {
+            for (const job of jobs) {
+                job.stop();
+            }
+            await Promise.all(watchers.map(async (watcher) => watcher.close()));
+        },
+    };
+}
+export async function mapEventToNotification(storeDir, event) {
+    if (!event.taskId) {
+        return null;
+    }
+    if (event.type === 'task.dependency_unlocked') {
+        return {
+            type: 'task.dependency_unlocked',
+            taskId: event.taskId,
+            title: await resolveTaskTitle(storeDir, event.taskId),
+        };
+    }
+    if (event.type !== 'task.status_changed' || !event.to) {
+        return null;
+    }
+    const notificationType = statusToNotificationType(event.to);
+    if (!notificationType) {
+        return null;
+    }
+    return {
+        type: notificationType,
+        taskId: event.taskId,
+        title: await resolveTaskTitle(storeDir, event.taskId),
+    };
+}
+function statusToNotificationType(status) {
+    if (status === 'completed') {
+        return 'task.completed';
+    }
+    if (status === 'failed') {
+        return 'task.failed';
+    }
+    if (status === 'paused') {
+        return 'task.paused';
+    }
+    if (status === 'waiting-review') {
+        return 'task.waiting-review';
+    }
+    return null;
+}
+async function resolveTaskTitle(storeDir, taskId) {
+    try {
+        const index = await readIndex(storeDir);
+        const record = index.tasks[String(taskId)];
+        if (!record) {
+            return `Task ${taskId}`;
+        }
+        const task = await readTaskFile(join(storeDir, 'tasks', record.file));
+        return task.title;
+    }
+    catch {
+        return `Task ${taskId}`;
+    }
+}
+function resolveRuntimeStores(cwd, homeDir) {
+    return [
+        resolveStoreDir({ cwd, homeDir, scope: 'project' }),
+        resolveStoreDir({ cwd, homeDir, scope: 'global' }),
+    ];
+}
+async function maybeAutoStartUnlockedTask(storeDir, event, options) {
+    if (event.type !== 'task.dependency_unlocked' || !event.taskId) {
+        return;
+    }
+    const task = await resolveTaskFromStore(storeDir, event.taskId);
+    if (!task || task.level !== 'L1' || task.assignee === 'human') {
+        return;
+    }
+    const config = await readConfig(storeDir);
+    const tool = task.assignee === 'auto' ? config.defaultAgent : task.assignee;
+    if (tool !== 'claude' && tool !== 'codex') {
+        return;
+    }
+    await (options.runAutoStart
+        ? options.runAutoStart({
+            taskId: task.id,
+            tool,
+            scope: task.scope,
+        })
+        : startTaskRun({
+            cwd: options.cwd,
+            homeDir: options.homeDir,
+            taskId: task.id,
+            tool,
+            scope: task.scope,
+        }));
+}
+async function resolveTaskFromStore(storeDir, taskId) {
+    const index = await readIndex(storeDir);
+    const record = index.tasks[String(taskId)];
+    if (!record) {
+        return null;
+    }
+    return readTaskFile(join(storeDir, 'tasks', record.file));
+}
+function createLaunchctlRunner(launchctlBin = process.env.HA_LAUNCHCTL_BIN ?? 'launchctl') {
+    return async (args) => {
+        const result = await execFileAsync(launchctlBin, args, {
+            env: process.env,
+        });
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+        };
+    };
+}
+function createDockerRunner(dockerBin = process.env.HA_DOCKER_BIN ?? 'docker') {
+    return async (args, options) => {
+        const result = await execFileAsync(dockerBin, args, {
+            cwd: options.cwd,
+            env: process.env,
+        });
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+        };
+    };
+}
+async function readFileIfExists(filePath) {
+    try {
+        return await readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return '';
+        }
+        throw error;
+    }
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/src/core/dag.js

@@ -0,0 +1,80 @@
+export function getExecutionOrder(index) {
+    const nodes = Object.keys(index.tasks);
+    if (nodes.length === 0) {
+        return [];
+    }
+    const indegree = new Map();
+    const adjacency = new Map();
+    for (const node of nodes) {
+        indegree.set(node, 0);
+        adjacency.set(node, []);
+    }
+    for (const edge of index.dag.edges) {
+        adjacency.set(edge.from, [...(adjacency.get(edge.from) ?? []), edge.to]);
+        indegree.set(edge.to, (indegree.get(edge.to) ?? 0) + 1);
+    }
+    const queue = [...nodes].filter((node) => (indegree.get(node) ?? 0) === 0);
+    const result = [];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (!node) {
+            continue;
+        }
+        result.push(Number(node));
+        for (const next of adjacency.get(node) ?? []) {
+            const nextDegree = (indegree.get(next) ?? 0) - 1;
+            indegree.set(next, nextDegree);
+            if (nextDegree === 0) {
+                queue.push(next);
+            }
+        }
+    }
+    return result;
+}
+export function getRunnableTasks(index) {
+    return Object.entries(index.tasks)
+        .filter(([, task]) => task.status === 'pending')
+        .filter(([, task]) => task.deps.every((depId) => index.tasks[String(depId)]?.status === 'completed'))
+        .map(([taskId]) => Number(taskId))
+        .sort((left, right) => left - right);
+}
+export function getBlockedTasks(index) {
+    return Object.entries(index.tasks)
+        .filter(([, task]) => task.status === 'pending')
+        .filter(([, task]) => task.deps.some((depId) => index.tasks[String(depId)]?.status !== 'completed'))
+        .map(([taskId]) => Number(taskId))
+        .sort((left, right) => left - right);
+}
+export function detectCycle(index) {
+    const nodes = new Set(Object.keys(index.tasks));
+    const indegree = new Map();
+    const adjacency = new Map();
+    for (const node of nodes) {
+        indegree.set(node, 0);
+        adjacency.set(node, []);
+    }
+    for (const edge of index.dag.edges) {
+        nodes.add(edge.from);
+        nodes.add(edge.to);
+        adjacency.set(edge.from, [...(adjacency.get(edge.from) ?? []), edge.to]);
+        indegree.set(edge.to, (indegree.get(edge.to) ?? 0) + 1);
+        indegree.set(edge.from, indegree.get(edge.from) ?? 0);
+    }
+    const queue = [...nodes].filter((node) => (indegree.get(node) ?? 0) === 0);
+    let visited = 0;
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (!node) {
+            continue;
+        }
+        visited += 1;
+        for (const next of adjacency.get(node) ?? []) {
+            const nextDegree = (indegree.get(next) ?? 0) - 1;
+            indegree.set(next, nextDegree);
+            if (nextDegree === 0) {
+                queue.push(next);
+            }
+        }
+    }
+    return visited !== nodes.size;
+}

package/dist/src/core/event-log.js

@@ -0,0 +1,34 @@
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { eventSchema } from '../types/index.js';
+const EVENTS_FILE = 'events.ndjson';
+export async function appendEvent(storeDir, event) {
+    const parsed = eventSchema.parse(event);
+    await mkdir(storeDir, { recursive: true });
+    await appendFile(join(storeDir, EVENTS_FILE), `${JSON.stringify(parsed)}\n`, 'utf8');
+}
+export async function readEvents(storeDir, filter = {}) {
+    const filePath = join(storeDir, EVENTS_FILE);
+    try {
+        const raw = await readFile(filePath, 'utf8');
+        return raw
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => eventSchema.parse(JSON.parse(line)))
+            .filter((event) => {
+            if (filter.taskId !== undefined && event.taskId !== filter.taskId) {
+                return false;
+            }
+            if (filter.type !== undefined && event.type !== filter.type) {
+                return false;
+            }
+            return true;
+        });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}

package/dist/src/core/lock.js

@@ -0,0 +1,25 @@
+import { open, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import lockfile from 'proper-lockfile';
+async function ensureFileExists(filePath) {
+    await mkdir(dirname(filePath), { recursive: true });
+    const handle = await open(filePath, 'a');
+    await handle.close();
+}
+export async function withLock(filePath, fn) {
+    await ensureFileExists(filePath);
+    const release = await lockfile.lock(filePath, {
+        retries: {
+            retries: 10,
+            factor: 1.5,
+            minTimeout: 10,
+            maxTimeout: 100,
+        },
+    });
+    try {
+        return await fn();
+    }
+    finally {
+        await release();
+    }
+}